Commit 157b5797 authored by Jørgen Lind's avatar Jørgen Lind
Browse files

Merge branch 'feature/jorgen.lind/CoordinateTransformer' into 'master'

GetVDSIJKGridDefinitionFromMetadata

See merge request !469
parents 3142a07d 358c98b7
Pipeline #67795 failed with stages
in 5 minutes and 29 seconds
......@@ -31,6 +31,10 @@ pybind11_add_module(core MODULE
PyGlobalState.h
PyExceptions.cpp
PyExceptions.h
PyCoordinateTransformer.cpp
PyCoordinateTransformer.h
PyIJKCoordinateTransformer.cpp
PyIJKCoordinateTransformer.h
)
if (MSVC AND (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
......
/****************************************************************************
** Copyright 2019 The Open Group
** Copyright 2019 Bluware, Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
****************************************************************************/
#include "PyCoordinateTransformer.h"
using namespace native;
void
PyCoordinateTransformer::initModule(py::module& m)
{
//AUTOGEN-BEGIN
// IJKGridDefinition
py::class_<IJKGridDefinition>
IJKGridDefinition_(m,"IJKGridDefinition", OPENVDS_DOCSTRING(IJKGridDefinition));
IJKGridDefinition_.def(py::init< >(), OPENVDS_DOCSTRING(IJKGridDefinition_IJKGridDefinition));
IJKGridDefinition_.def(py::init<native::DoubleVector3, native::DoubleVector3, native::DoubleVector3, native::DoubleVector3>(), py::arg("origin").none(false), py::arg("iUnitStep").none(false), py::arg("jUnitStep").none(false), py::arg("kUnitStep").none(false), OPENVDS_DOCSTRING(IJKGridDefinition_IJKGridDefinition_2));
IJKGridDefinition_.def(py::self == py::self);
IJKGridDefinition_.def_readwrite("origin" , &IJKGridDefinition::origin , OPENVDS_DOCSTRING(IJKGridDefinition_origin));
IJKGridDefinition_.def_readwrite("iUnitStep" , &IJKGridDefinition::iUnitStep , OPENVDS_DOCSTRING(IJKGridDefinition_iUnitStep));
IJKGridDefinition_.def_readwrite("jUnitStep" , &IJKGridDefinition::jUnitStep , OPENVDS_DOCSTRING(IJKGridDefinition_jUnitStep));
IJKGridDefinition_.def_readwrite("kUnitStep" , &IJKGridDefinition::kUnitStep , OPENVDS_DOCSTRING(IJKGridDefinition_kUnitStep));
// VDSIJKGridDefinition
py::class_<VDSIJKGridDefinition, IJKGridDefinition>
VDSIJKGridDefinition_(m,"VDSIJKGridDefinition", OPENVDS_DOCSTRING(VDSIJKGridDefinition));
VDSIJKGridDefinition_.def(py::init< >(), OPENVDS_DOCSTRING(VDSIJKGridDefinition_VDSIJKGridDefinition));
VDSIJKGridDefinition_.def(py::init<const native::IJKGridDefinition &, native::IntVector3>(), py::arg("ijkGridDefinition").none(false), py::arg("dimensionMap").none(false), OPENVDS_DOCSTRING(VDSIJKGridDefinition_VDSIJKGridDefinition_2));
VDSIJKGridDefinition_.def(py::self == py::self);
VDSIJKGridDefinition_.def_readwrite("dimensionMap" , &VDSIJKGridDefinition::dimensionMap, OPENVDS_DOCSTRING(VDSIJKGridDefinition_dimensionMap));
//AUTOGEN-END
// IMPLEMENTED : // M4
// IMPLEMENTED : py::class_<M4>
// IMPLEMENTED : M4_(m,"M4", OPENVDS_DOCSTRING(M4));
// IMPLEMENTED :
// IMPLEMENTED : M4_.def_readwrite("data" , &M4::data , OPENVDS_DOCSTRING(M4_data));
// IMPLEMENTED :
// IMPLEMENTED : m.def("fastInvert" , static_cast<void(*)(native::M4 &)>(&fastInvert), py::arg("m").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(fastInvert));
}
/****************************************************************************
** Copyright 2021 The Open Group
** Copyright 2021 Bluware, Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
****************************************************************************/
#ifndef PYCOORDINATETRANSFORMER_H_INCLUDED
#define PYCOORDINATETRANSFORMER_H_INCLUDED
#include "PyGlobal.h"
class PyCoordinateTransformer
{
public:
static void initModule(py::module& m);
};
#endif
......@@ -17,11 +17,98 @@
#include "PyGlobal.h"
#include <OpenVDS/Vector.h>
using namespace native;
template<typename ELEM> struct ElemTraits;
template<> struct ElemTraits<int> { static const char* name() { return "Int"; }};
template<> struct ElemTraits<float> { static const char* name() { return "Float"; }};
template<> struct ElemTraits<double> { static const char* name() { return "Double"; }};
// Vector Class Helper
template<typename T, size_t COUNT>
struct VCH
{
template<typename CDEF>
static void addMembers(CDEF&) {}
};
template<typename T> struct VCH<T, 1> { template<typename CDEF> static void addMembers(CDEF& class_) { VCH<T, 0>::addMembers(class_); class_.def_readwrite("X", &T::X); } };
template<typename T> struct VCH<T, 2> { template<typename CDEF> static void addMembers(CDEF& class_) { VCH<T, 1>::addMembers(class_); class_.def_readwrite("Y", &T::Y); } };
template<typename T> struct VCH<T, 3> { template<typename CDEF> static void addMembers(CDEF& class_) { VCH<T, 2>::addMembers(class_); class_.def_readwrite("Z", &T::Z); } };
template<typename T> struct VCH<T, 4> { template<typename CDEF> static void addMembers(CDEF& class_) { VCH<T, 3>::addMembers(class_); class_.def_readwrite("T", &T::T); } };
// Vector Name Helper
template<typename T, size_t COUNT>
struct VNH
{
static std::string className()
{
auto name = std::string(ElemTraits<T>::name()) + "Vector" + std::to_string(COUNT);
return name;
}
};
// Vector Class Helper Base
template<typename T, size_t COUNT> struct VCHB;
//template<typename T, typename ELEM> struct VCHB<T, ELEM, 2> { template<typename CDEF> static void addStuff(CDEF& class_) { class_.def(py::init<ELEM, ELEM>()); } };
template<typename T> struct VCHB<T, 2> { template<typename CDEF> static void addCtor(CDEF& class_) { class_.def(py::init<T, T>()); } };
template<typename T> struct VCHB<T, 3> { template<typename CDEF> static void addCtor(CDEF& class_) { class_.def(py::init<T, T, T>()); } };
template<typename T> struct VCHB<T, 4> { template<typename CDEF> static void addCtor(CDEF& class_) { class_.def(py::init<T, T, T, T>()); } };
template<typename T, size_t COUNT>
struct VectorHelper
{
static std::string repr(Vector<T, COUNT>* self)
{
auto str = VNH<T, COUNT>::className();
auto prefix = std::string("(");
auto data = (T *)self;
for (int i = 0; i < COUNT; ++i) {
str += prefix + std::to_string(data[i]);
prefix = std::string(", ");
}
return str + ")";
}
static void init(py::module& m)
{
py::class_<Vector<T, COUNT>>
class_(m, VNH<T, COUNT>::className().c_str());
class_.def(py::init<>());
VCHB<T, COUNT>::addCtor(class_);
class_.def("__iter__", [](Vector<T, COUNT>* self) { return py::make_iterator((typename T*)self, (typename T*)self + COUNT); });
class_.def("__repr__", repr);
class_.def(py::self == py::self);
class_.def(py::self != py::self);
class_.def("__eq__", [](Vector<T, COUNT> const& self, typename VectorAdapter<T, COUNT>::AdaptedType const& rhs) -> bool
{
return self == Vector<T, COUNT>(rhs);
});
class_.def("__ne__", [](Vector<T, COUNT> const& self, typename VectorAdapter<T, COUNT>::AdaptedType const& rhs) -> bool
{
return self != Vector<T, COUNT>(rhs);
});
VCH<Vector<T, COUNT>, COUNT>::addMembers(class_);
}
};
void
PyGlobal::initModule(py::module& m)
{
VectorHelper<int, 2> ::init(m);
VectorHelper<int, 3> ::init(m);
VectorHelper<int, 4> ::init(m);
VectorHelper<float, 2> ::init(m);
VectorHelper<float, 3> ::init(m);
VectorHelper<float, 4> ::init(m);
VectorHelper<double, 2>::init(m);
VectorHelper<double, 3>::init(m);
//VectorHelper<native::DoubleVector4>::init(m);
// These are opaque pointers, so they must not be destructed from pybind11 code
py::class_<VDS, std::unique_ptr<VDS, py::nodelete>>
VDS_(m, "VDS");
......
......@@ -277,7 +277,7 @@ struct BLOB
}
};
template<typename T, size_t N>
template<typename T, int N>
struct VectorAdapter
{
......
/****************************************************************************
** Copyright 2021 The Open Group
** Copyright 2021 Bluware, Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
****************************************************************************/
#include "PyIJKCoordinateTransformer.h"
#include <OpenVDS/IJKCoordinateTransformer.h>
using namespace native;
void
PyIJKCoordinateTransformer::initModule(py::module& m)
{
//AUTOGEN-BEGIN
// IJKCoordinateTransformer
py::class_<IJKCoordinateTransformer>
IJKCoordinateTransformer_(m,"IJKCoordinateTransformer", OPENVDS_DOCSTRING(IJKCoordinateTransformer));
IJKCoordinateTransformer_.def(py::init< >(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKCoordinateTransformer));
IJKCoordinateTransformer_.def(py::init<const native::IJKGridDefinition &, const native::IntVector3 &>(), py::arg("ijkGridDefinition").none(false), py::arg("ijkSize").none(false), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKCoordinateTransformer_2));
IJKCoordinateTransformer_.def(py::init<const native::IJKGridDefinition &, const native::IntVector3 &, const native::IntVector3 &>(), py::arg("ijkGridDefinition").none(false), py::arg("ijkSize").none(false), py::arg("ijkToVoxelDimensionMap").none(false), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKCoordinateTransformer_3));
IJKCoordinateTransformer_.def(py::init<const native::VDSIJKGridDefinition &, const native::IntVector3 &>(), py::arg("vdsIJKGridDefinition").none(false), py::arg("ijkSize").none(false), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKCoordinateTransformer_4));
IJKCoordinateTransformer_.def(py::init<const native::IJKGridDefinition &, const native::IntVector3 &, const native::DoubleVector3 &, const native::DoubleVector3 &>(), py::arg("ijkGridDefinition").none(false), py::arg("ijkSize").none(false), py::arg("ijkAnnotationStart").none(false), py::arg("ijkAnnotationEnd").none(false), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKCoordinateTransformer_5));
IJKCoordinateTransformer_.def(py::init<const native::IJKGridDefinition &, const native::IntVector3 &, const native::IntVector3 &, const native::DoubleVector3 &, const native::DoubleVector3 &>(), py::arg("ijkGridDefinition").none(false), py::arg("ijkSize").none(false), py::arg("ijkToVoxelDimensionMap").none(false), py::arg("ijkAnnotationStart").none(false), py::arg("ijkAnnotationEnd").none(false), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKCoordinateTransformer_6));
IJKCoordinateTransformer_.def(py::init<const native::VDSIJKGridDefinition &, const native::IntVector3 &, const native::DoubleVector3 &, const native::DoubleVector3 &>(), py::arg("vdsIJKGridDefinition").none(false), py::arg("ijkSize").none(false), py::arg("ijkAnnotationStart").none(false), py::arg("ijkAnnotationEnd").none(false), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKCoordinateTransformer_7));
IJKCoordinateTransformer_.def(py::init<native::VolumeDataLayout * >(), py::arg("layout").none(false), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKCoordinateTransformer_8));
IJKCoordinateTransformer_.def("IJKPositionToWorld" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType ijkPosition) { return (DoubleVector3Adapter::AdaptedType)(self->IJKPositionToWorld(ijkPosition)); }, py::arg("ijkPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKPositionToWorld));
IJKCoordinateTransformer_.def("IJKIndexToWorld" , [](IJKCoordinateTransformer* self, IntVector3Adapter::AdaptedType ijkIndex) { return (DoubleVector3Adapter::AdaptedType)(self->IJKIndexToWorld(ijkIndex)); }, py::arg("ijkIndex").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKIndexToWorld));
IJKCoordinateTransformer_.def("IJKPositionToAnnotation" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType ijkPosition) { return (DoubleVector3Adapter::AdaptedType)(self->IJKPositionToAnnotation(ijkPosition)); }, py::arg("ijkPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKPositionToAnnotation));
IJKCoordinateTransformer_.def("IJKIndexToAnnotation" , [](IJKCoordinateTransformer* self, IntVector3Adapter::AdaptedType ijkIndex) { return (DoubleVector3Adapter::AdaptedType)(self->IJKIndexToAnnotation(ijkIndex)); }, py::arg("ijkIndex").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKIndexToAnnotation));
IJKCoordinateTransformer_.def("IJKPositionToVoxelPosition" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType ijkPosition) { return (DoubleVector3Adapter::AdaptedType)(self->IJKPositionToVoxelPosition(ijkPosition)); }, py::arg("ijkPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKPositionToVoxelPosition));
IJKCoordinateTransformer_.def("IJKIndexToVoxelIndex" , [](IJKCoordinateTransformer* self, IntVector3Adapter::AdaptedType ijkIndex) { return (IntVector3Adapter::AdaptedType)(self->IJKIndexToVoxelIndex(ijkIndex)); }, py::arg("ijkIndex").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKIndexToVoxelIndex));
IJKCoordinateTransformer_.def("worldToIJKPosition" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType worldPosition) { return (DoubleVector3Adapter::AdaptedType)(self->WorldToIJKPosition(worldPosition)); }, py::arg("worldPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_WorldToIJKPosition));
IJKCoordinateTransformer_.def("worldToIJKIndex" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType worldPosition) { return (IntVector3Adapter::AdaptedType)(self->WorldToIJKIndex(worldPosition)); }, py::arg("worldPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_WorldToIJKIndex));
IJKCoordinateTransformer_.def("worldToAnnotation" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType worldPosition) { return (DoubleVector3Adapter::AdaptedType)(self->WorldToAnnotation(worldPosition)); }, py::arg("worldPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_WorldToAnnotation));
IJKCoordinateTransformer_.def("worldToVoxelPosition" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType worldPosition) { return (DoubleVector3Adapter::AdaptedType)(self->WorldToVoxelPosition(worldPosition)); }, py::arg("worldPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_WorldToVoxelPosition));
IJKCoordinateTransformer_.def("worldToVoxelIndex" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType worldPosition) { return (IntVector3Adapter::AdaptedType)(self->WorldToVoxelIndex(worldPosition)); }, py::arg("worldPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_WorldToVoxelIndex));
IJKCoordinateTransformer_.def("annotationToIJKPosition" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType annotationPosition) { return (DoubleVector3Adapter::AdaptedType)(self->AnnotationToIJKPosition(annotationPosition)); }, py::arg("annotationPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_AnnotationToIJKPosition));
IJKCoordinateTransformer_.def("annotationToIJKIndex" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType annotationPosition) { return (IntVector3Adapter::AdaptedType)(self->AnnotationToIJKIndex(annotationPosition)); }, py::arg("annotationPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_AnnotationToIJKIndex));
IJKCoordinateTransformer_.def("annotationToWorld" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType annotationPosition) { return (DoubleVector3Adapter::AdaptedType)(self->AnnotationToWorld(annotationPosition)); }, py::arg("annotationPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_AnnotationToWorld));
IJKCoordinateTransformer_.def("annotationToVoxelPosition" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType annotationPosition) { return (DoubleVector3Adapter::AdaptedType)(self->AnnotationToVoxelPosition(annotationPosition)); }, py::arg("annotationPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_AnnotationToVoxelPosition));
IJKCoordinateTransformer_.def("annotationToVoxelIndex" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType annotationPosition) { return (IntVector3Adapter::AdaptedType)(self->AnnotationToVoxelIndex(annotationPosition)); }, py::arg("annotationPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_AnnotationToVoxelIndex));
IJKCoordinateTransformer_.def("voxelPositionToIJKPosition" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType voxelPosition) { return (DoubleVector3Adapter::AdaptedType)(self->VoxelPositionToIJKPosition(voxelPosition)); }, py::arg("voxelPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_VoxelPositionToIJKPosition));
IJKCoordinateTransformer_.def("voxelIndexToIJKIndex" , [](IJKCoordinateTransformer* self, IntVector3Adapter::AdaptedType voxelIndex) { return (IntVector3Adapter::AdaptedType)(self->VoxelIndexToIJKIndex(voxelIndex)); }, py::arg("voxelIndex").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_VoxelIndexToIJKIndex));
IJKCoordinateTransformer_.def("voxelPositionToWorld" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType voxelPosition) { return (DoubleVector3Adapter::AdaptedType)(self->VoxelPositionToWorld(voxelPosition)); }, py::arg("voxelPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_VoxelPositionToWorld));
IJKCoordinateTransformer_.def("voxelIndexToWorld" , [](IJKCoordinateTransformer* self, IntVector3Adapter::AdaptedType voxelIndex) { return (DoubleVector3Adapter::AdaptedType)(self->VoxelIndexToWorld(voxelIndex)); }, py::arg("voxelIndex").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_VoxelIndexToWorld));
IJKCoordinateTransformer_.def("voxelPositionToAnnotation" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType voxelPosition) { return (DoubleVector3Adapter::AdaptedType)(self->VoxelPositionToAnnotation(voxelPosition)); }, py::arg("voxelPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_VoxelPositionToAnnotation));
IJKCoordinateTransformer_.def("voxelIndexToAnnotation" , [](IJKCoordinateTransformer* self, IntVector3Adapter::AdaptedType voxelIndex) { return (DoubleVector3Adapter::AdaptedType)(self->VoxelIndexToAnnotation(voxelIndex)); }, py::arg("voxelIndex").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_VoxelIndexToAnnotation));
IJKCoordinateTransformer_.def("isIJKPositionOutOfRange" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType ijkPosition) { return self->IsIJKPositionOutOfRange(ijkPosition); }, py::arg("ijkPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IsIJKPositionOutOfRange));
IJKCoordinateTransformer_.def("isIJKIndexOutOfRange" , [](IJKCoordinateTransformer* self, IntVector3Adapter::AdaptedType ijkIndex) { return self->IsIJKIndexOutOfRange(ijkIndex); }, py::arg("ijkIndex").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IsIJKIndexOutOfRange));
IJKCoordinateTransformer_.def("isVoxelPositionOutOfRange" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType voxelPosition) { return self->IsVoxelPositionOutOfRange(voxelPosition); }, py::arg("voxelPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IsVoxelPositionOutOfRange));
IJKCoordinateTransformer_.def("isVoxelIndexOutOfRange" , [](IJKCoordinateTransformer* self, IntVector3Adapter::AdaptedType voxelIndex) { return self->IsVoxelIndexOutOfRange(voxelIndex); }, py::arg("voxelIndex").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IsVoxelIndexOutOfRange));
IJKCoordinateTransformer_.def("convertIJKPositionToIndex" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType ijkPosition) { return (IntVector3Adapter::AdaptedType)(self->ConvertIJKPositionToIndex(ijkPosition)); }, py::arg("ijkPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_ConvertIJKPositionToIndex));
IJKCoordinateTransformer_.def("convertVoxelPositionToIndex" , [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType voxelPosition) { return (IntVector3Adapter::AdaptedType)(self->ConvertVoxelPositionToIndex(voxelPosition)); }, py::arg("voxelPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_ConvertVoxelPositionToIndex));
IJKCoordinateTransformer_.def(py::self == py::self);
IJKCoordinateTransformer_.def("errorCodeIfIJKPositionOutOfRange", [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType ijkPosition) { return self->ErrorCodeIfIJKPositionOutOfRange(ijkPosition); }, py::arg("ijkPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_ErrorCodeIfIJKPositionOutOfRange));
IJKCoordinateTransformer_.def("errorCodeIfVoxelPositionOutOfRange", [](IJKCoordinateTransformer* self, DoubleVector3Adapter::AdaptedType voxelPosition) { return self->ErrorCodeIfVoxelPositionOutOfRange(voxelPosition); }, py::arg("voxelPosition").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_ErrorCodeIfVoxelPositionOutOfRange));
//AUTOGEN-END
// IMPLEMENTED : IJKCoordinateTransformer_.def("IJKGrid" , static_cast<const native::IJKGridDefinition &(IJKCoordinateTransformer::*)() const>(&IJKCoordinateTransformer::IJKGrid), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKGrid));
// IMPLEMENTED : IJKCoordinateTransformer_.def("IJKSize" , [](IJKCoordinateTransformer* self) { return (IntVector3Adapter::AdaptedType)(self->IJKSize()); }, py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKSize));
// IMPLEMENTED : IJKCoordinateTransformer_.def("IJKToVoxelDimensionMap" , [](IJKCoordinateTransformer* self) { return (IntVector3Adapter::AdaptedType)(self->IJKToVoxelDimensionMap()); }, py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKToVoxelDimensionMap));
// IMPLEMENTED : IJKCoordinateTransformer_.def("IJKToWorldTransform" , static_cast<const native::DoubleMatrix4x4 &(IJKCoordinateTransformer::*)() const>(&IJKCoordinateTransformer::IJKToWorldTransform), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKToWorldTransform));
// IMPLEMENTED : IJKCoordinateTransformer_.def("worldToIJKTransform" , static_cast<const native::DoubleMatrix4x4 &(IJKCoordinateTransformer::*)() const>(&IJKCoordinateTransformer::WorldToIJKTransform), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_WorldToIJKTransform));
// IMPLEMENTED : IJKCoordinateTransformer_.def("IJKAnnotationStart" , [](IJKCoordinateTransformer* self) { return (DoubleVector3Adapter::AdaptedType)(self->IJKAnnotationStart()); }, py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKAnnotationStart));
// IMPLEMENTED : IJKCoordinateTransformer_.def("IJKAnnotationEnd" , [](IJKCoordinateTransformer* self) { return (DoubleVector3Adapter::AdaptedType)(self->IJKAnnotationEnd()); }, py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKAnnotationEnd));
// IMPLEMENTED : IJKCoordinateTransformer_.def("annotationsDefined" , static_cast<bool(IJKCoordinateTransformer::*)() const>(&IJKCoordinateTransformer::AnnotationsDefined), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_AnnotationsDefined));
IJKCoordinateTransformer_.def_property_readonly("IJKGrid" , static_cast<const native::IJKGridDefinition &(IJKCoordinateTransformer::*)() const>(&IJKCoordinateTransformer::IJKGrid), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKGrid));
IJKCoordinateTransformer_.def_property_readonly("IJKSize" , [](IJKCoordinateTransformer* self) { return (IntVector3Adapter::AdaptedType)(self->IJKSize()); }, py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKSize));
IJKCoordinateTransformer_.def_property_readonly("IJKToVoxelDimensionMap" , [](IJKCoordinateTransformer* self) { return (IntVector3Adapter::AdaptedType)(self->IJKToVoxelDimensionMap()); }, py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKToVoxelDimensionMap));
IJKCoordinateTransformer_.def_property_readonly("IJKToWorldTransform" , static_cast<const native::DoubleMatrix4x4 &(IJKCoordinateTransformer::*)() const>(&IJKCoordinateTransformer::IJKToWorldTransform), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKToWorldTransform));
IJKCoordinateTransformer_.def_property_readonly("worldToIJKTransform" , static_cast<const native::DoubleMatrix4x4 &(IJKCoordinateTransformer::*)() const>(&IJKCoordinateTransformer::WorldToIJKTransform), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_WorldToIJKTransform));
IJKCoordinateTransformer_.def_property_readonly("IJKAnnotationStart" , [](IJKCoordinateTransformer* self) { return (DoubleVector3Adapter::AdaptedType)(self->IJKAnnotationStart()); }, py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKAnnotationStart));
IJKCoordinateTransformer_.def_property_readonly("IJKAnnotationEnd" , [](IJKCoordinateTransformer* self) { return (DoubleVector3Adapter::AdaptedType)(self->IJKAnnotationEnd()); }, py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_IJKAnnotationEnd));
IJKCoordinateTransformer_.def_property_readonly("annotationsDefined" , static_cast<bool(IJKCoordinateTransformer::*)() const>(&IJKCoordinateTransformer::AnnotationsDefined), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(IJKCoordinateTransformer_AnnotationsDefined));
}
/****************************************************************************
** Copyright 2021 The Open Group
** Copyright 2021 Bluware, Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
****************************************************************************/
#ifndef PYIJKCOORDINATETRANSFORMER_H_INCLUDED
#define PYIJKCOORDINATETRANSFORMER_H_INCLUDED
#include "PyGlobal.h"
class PyIJKCoordinateTransformer
{
public:
static void initModule(py::module& m);
};
#endif
......@@ -55,6 +55,8 @@ PyVolumeDataLayout::initModule(py::module& m)
VolumeDataLayout_.def("getDimensionUnit" , static_cast<const char *(VolumeDataLayout::*)(int) const>(&VolumeDataLayout::GetDimensionUnit), py::arg("dimension").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(VolumeDataLayout_GetDimensionUnit));
VolumeDataLayout_.def("getDimensionMin" , static_cast<float(VolumeDataLayout::*)(int) const>(&VolumeDataLayout::GetDimensionMin), py::arg("dimension").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(VolumeDataLayout_GetDimensionMin));
VolumeDataLayout_.def("getDimensionMax" , static_cast<float(VolumeDataLayout::*)(int) const>(&VolumeDataLayout::GetDimensionMax), py::arg("dimension").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(VolumeDataLayout_GetDimensionMax));
VolumeDataLayout_.def("getVDSIJKGridDefinitionFromMetadata", static_cast<native::VDSIJKGridDefinition(VolumeDataLayout::*)() const>(&VolumeDataLayout::GetVDSIJKGridDefinitionFromMetadata), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(VolumeDataLayout_GetVDSIJKGridDefinitionFromMetadata));
VolumeDataLayout_.def_property_readonly("VDSIJKGridDefinitionFromMetadata", &VolumeDataLayout::GetVDSIJKGridDefinitionFromMetadata, OPENVDS_DOCSTRING(VolumeDataLayout_GetVDSIJKGridDefinitionFromMetadata));
VolumeDataLayout_.def("isChannelUseNoValue" , static_cast<bool(VolumeDataLayout::*)(int) const>(&VolumeDataLayout::IsChannelUseNoValue), py::arg("channel").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(VolumeDataLayout_IsChannelUseNoValue));
VolumeDataLayout_.def("getChannelNoValue" , static_cast<float(VolumeDataLayout::*)(int) const>(&VolumeDataLayout::GetChannelNoValue), py::arg("channel").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(VolumeDataLayout_GetChannelNoValue));
VolumeDataLayout_.def("getChannelIntegerScale" , static_cast<float(VolumeDataLayout::*)(int) const>(&VolumeDataLayout::GetChannelIntegerScale), py::arg("channel").none(false), py::call_guard<py::gil_scoped_release>(), OPENVDS_DOCSTRING(VolumeDataLayout_GetChannelIntegerScale));
......
......@@ -34,6 +34,8 @@
#include "PyVolumeSampler.h"
#include "PyGlobalState.h"
#include "PyExceptions.h"
#include "PyCoordinateTransformer.h"
#include "PyIJKCoordinateTransformer.h"
PYBIND11_MODULE(core, m) {
......@@ -52,4 +54,6 @@ PYBIND11_MODULE(core, m) {
PyVolumeSampler::initModule(m);
PyGlobalState::initModule(m);
PyExceptions::initModule(m);
PyCoordinateTransformer::initModule(m);
PyIJKCoordinateTransformer::initModule(m);
}
......@@ -78,6 +78,12 @@ static const char *__doc_OpenVDS_AWSOpenOptions_secretKey = R"doc()doc";
static const char *__doc_OpenVDS_AWSOpenOptions_sessionToken = R"doc()doc";
static const char *__doc_OpenVDS_Assign = R"doc()doc";
static const char *__doc_OpenVDS_AssignMember = R"doc()doc";
static const char *__doc_OpenVDS_AssignMember_2 = R"doc()doc";
static const char *__doc_OpenVDS_AzureOpenOptions = R"doc(Options for opening a VDS in Azure)doc";
static const char *__doc_OpenVDS_AzureOpenOptions_AzureOpenOptions = R"doc()doc";
......@@ -178,6 +184,8 @@ static const char *__doc_OpenVDS_CalculateNoise3D = R"doc()doc";
static const char *__doc_OpenVDS_CalculateNoise4D = R"doc()doc";
static const char *__doc_OpenVDS_Clear = R"doc()doc";
static const char *__doc_OpenVDS_Close =
R"doc(Close a VDS and free up all associated resources
......@@ -670,6 +678,8 @@ static const char *__doc_OpenVDS_CreateVolumeDataReadWriteAccessor_41 = R"doc()d
static const char *__doc_OpenVDS_CreateVolumeDataReadWriteAccessor_42 = R"doc()doc";
static const char *__doc_OpenVDS_CrossProduct = R"doc()doc";
static const char *__doc_OpenVDS_DMSOpenOptions = R"doc()doc";
static const char *__doc_OpenVDS_DMSOpenOptions_DMSOpenOptions = R"doc()doc";
......@@ -770,6 +780,10 @@ static const char *__doc_OpenVDS_DimensionsND_Dimensions_35 = R"doc()doc";
static const char *__doc_OpenVDS_DimensionsND_Dimensions_45 = R"doc()doc";
static const char *__doc_OpenVDS_DotProduct = R"doc()doc";
static const char *__doc_OpenVDS_DotProduct_2 = R"doc()doc";
static const char *__doc_OpenVDS_Error = R"doc()doc";
static const char *__doc_OpenVDS_Error_code = R"doc()doc";
......@@ -1176,6 +1190,187 @@ static const char *__doc_OpenVDS_IHasVolumeDataAccess_GetVolumeDataAccessManager
static const char *__doc_OpenVDS_IHasVolumeDataAccess_IHasVolumeDataAccess = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer =
R"doc(<summary> IJKCoordinateTransformer may be used to transform between
the following three-dimensional index and coordinate systems of a
volume:
IJK Index - a 3D index into the volume based on IJK dimensions.
Dimensions I and J are usually horizontal directions, whereas K is
usually the vertical direction. Transforms are provided to/from
integer IJK indexes and also floating-point IJK positions.
World Coordinate - a world position, related to IJK through the IJK
grid definition provided on construction.
Annotation Coordinate - a coordinate position based on the annotation
axes of the volume (inline, crossline, depth, time, etc.). The order
of annotation coordinate values correspond to the volume axes for each
IJK dimension. That is, the annotation coordinate X value specifies
the coordinate for the annotation axis corresponding to the I
direction, and so on. When used with a VDS, annotation coordinates are
based on the VDS axis descriptors.
Voxel Index - a 3D index into the volume based on volume data
dimesions, where dimension 0 is the data dimension that changes the
fastest, dimension 1 is the data dimension that changes second
fastest, etc. Transforms are provided to/from integer voxel indexes
and also floating-point voxel positions. When used with a VDS, voxel
index 0 refers to dimension 0, ranging from 0 to Dimension0Size - 1,
and so on. The relationship between IJK dimensions and voxel
dimensions is controlled by the IJK dimension map provided at
construction. If the dimension map is (0, 1, 2), the IJK dimensions
are the same as voxel dimensions. However, it is often the case that
the dimension map is not (0, 1, 2), and so IJK dimensions are not the
same as voxel dimensions, especially when used with a VDS. When used
with a VDS, the dimension map is often set to (2, 1, 0), meaning that
IJK corresponds to voxel dimensions (2, 1, 0). However, this is not a
strict rule, and the dimension map will generally be defined based on
the VDS axis descriptors. If a particular VDS axis is given the name
"I", "J", or "K", that axis index will be considered as dimension I,
J, or K. This is not very common. If a particular VDS axis is given
the name "Inline", it will be considered as dimension I. If a
particular VDS axis is given the name "Crossline", it will be
considered as dimension J. If a particular VDS axis is given the name
"Time", "Depth", or "Sample", it will be considered as dimension K.
</summary>)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_AnnotationToIJKIndex = R"doc(Transform the given annotation position to a IJK index)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_AnnotationToIJKPosition = R"doc(Transform the given annotation position to a IJK position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_AnnotationToVoxelIndex = R"doc(Transform the given annotation position to a voxel index)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_AnnotationToVoxelPosition = R"doc(Transform the given annotation position to a voxel position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_AnnotationToWorld = R"doc(Transform the given annotation position to a world position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_AnnotationsDefined =
R"doc(Whether or not the annotation start/end coordinates are set, which
defines the annotation coordinate system)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_ConvertIJKPositionToIndex =
R"doc(Convert the given IJK position to IJK index. Return (-1, -1, -1) if
any component is outside valid range.)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_ConvertVoxelPositionToIndex =
R"doc(Convert the given voxel position to voxel index. Return (-1, -1, -1)
if any component is outside valid range.)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_ErrorCodeIfIJKPositionOutOfRange = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_ErrorCodeIfVoxelPositionOutOfRange = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_HomogeneousMultiply = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKAnnotationEnd =
R"doc(The annotation end coordinates, corresponding to max IJK index (i.e.
IJKSize - (1, 1, 1)))doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKAnnotationStart =
R"doc(The annotation start coordinates, corresponding to min IJK index (i.e.
0, 0, 0))doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKCoordinateTransformer = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKCoordinateTransformer_2 = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKCoordinateTransformer_3 = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKCoordinateTransformer_4 = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKCoordinateTransformer_5 = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKCoordinateTransformer_6 = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKCoordinateTransformer_7 = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKCoordinateTransformer_8 = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKGrid =
R"doc(The IJK grid definition relating IJK coordinates to world XYZ
coordinates)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKIndexToAnnotation = R"doc(Transform the given IJK index to an annotation position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKIndexToVoxelIndex = R"doc(Transform the given IJK index to a voxel index)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKIndexToWorld = R"doc(Transform the given IJK index to a world position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKPositionToAnnotation = R"doc(Transform the given IJK position to an annotation position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKPositionToVoxelPosition = R"doc(Transform the given IJK position to a voxel position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKPositionToWorld = R"doc(Transform the given IJK position to a world position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKSize = R"doc(The number of voxels in each IJK dimension)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKToVoxelDimensionMap = R"doc(Mapping from IJK to voxel volume dimensions)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IJKToWorldTransform = R"doc(The matrix used to transform from IJK coordinates to world coordinates)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_InitTransformMatrixes = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_InverseMatrix = R"doc()doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IsIJKIndexOutOfRange = R"doc(Determine whether the given IJK index is out of range)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IsIJKPositionOutOfRange = R"doc(Determine whether the given IJK position is out of range)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IsVoxelIndexOutOfRange = R"doc(Determine whether the given voxel index is out of range)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_IsVoxelPositionOutOfRange = R"doc(Determine whether the given voxel position is out of range)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_VoxelIndexToAnnotation = R"doc(Transform the given voxel index to an annotation position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_VoxelIndexToIJKIndex = R"doc(Transform the given voxel index to an IJK index)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_VoxelIndexToWorld = R"doc(Transform the given voxel index to a world position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_VoxelPositionToAnnotation = R"doc(Transform the given voxel position to an annotation position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_VoxelPositionToIJKPosition = R"doc(Transform the given voxel position to an IJK position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_VoxelPositionToWorld = R"doc(Transform the given voxel position to a world position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_WorldToAnnotation = R"doc(Transform the given world position to an annotation position)doc";
static const char *__doc_OpenVDS_IJKCoordinateTransformer_WorldToIJKIndex = R"doc(Transform the given world position to a IJK index)doc";