6 #ifndef OPENVDB_MATH_MAPS_HAS_BEEN_INCLUDED
7 #define OPENVDB_MATH_MAPS_HAS_BEEN_INCLUDED
35 class ScaleTranslateMap;
36 class UniformScaleMap;
37 class UniformScaleTranslateMap;
40 class NonlinearFrustumMap;
58 template<>
struct is_linear<UniformScaleMap> {
static const bool value =
true; };
60 template<>
struct is_linear<TranslationMap> {
static const bool value =
true; };
62 template<>
struct is_linear<UniformScaleTranslateMap> {
static const bool value =
true; };
79 template<
typename T>
struct is_scale {
static const bool value =
false; };
139 using MapFactory =
Ptr (*)();
150 template<
typename MapT>
bool isType()
const {
return this->
type() == MapT::mapType(); }
153 virtual bool isEqual(
const MapBase& other)
const = 0;
156 virtual bool isLinear()
const = 0;
158 virtual bool hasUniformScale()
const = 0;
161 virtual Vec3d applyInverseMap(
const Vec3d&
in)
const = 0;
175 virtual double determinant()
const = 0;
176 virtual double determinant(
const Vec3d&)
const = 0;
183 virtual Vec3d voxelSize()
const = 0;
184 virtual Vec3d voxelSize(
const Vec3d&)
const = 0;
187 virtual void read(std::istream&) = 0;
188 virtual void write(std::ostream&)
const = 0;
223 virtual Vec3d applyInverseJacobian(
const Vec3d&
in)
const = 0;
224 virtual Vec3d applyInverseJacobian(
const Vec3d&
in,
const Vec3d& domainPos)
const = 0;
249 template<
typename MapT>
252 return other.
isType<MapT>() && (
self == *static_cast<const MapT*>(&other));
273 static bool isRegistered(
const Name&);
279 static void unregisterMap(
const Name&);
297 #if OPENVDB_ABI_VERSION_NUMBER >= 8
298 #define OPENVDB_MAP_CLASS_SPECIFIER final
299 #define OPENVDB_MAP_FUNC_SPECIFIER final
301 #define OPENVDB_MAP_CLASS_SPECIFIER
302 #define OPENVDB_MAP_FUNC_SPECIFIER override
316 mMatrix(
Mat4d::identity()),
317 mMatrixInv(
Mat4d::identity()),
318 mJacobianInv(
Mat3d::identity()),
320 mVoxelSize(
Vec3d(1,1,1)),
332 updateAcceleration();
339 "Tried to initialize an affine transform from a non-affine 4x4 matrix");
341 updateAcceleration();
346 mMatrix(other.mMatrix),
347 mMatrixInv(other.mMatrixInv),
348 mJacobianInv(other.mJacobianInv),
349 mDeterminant(other.mDeterminant),
350 mVoxelSize(other.mVoxelSize),
351 mIsDiagonal(other.mIsDiagonal),
352 mIsIdentity(other.mIsIdentity)
358 mMatrix(first.mMatrix * second.mMatrix)
360 updateAcceleration();
363 ~AffineMap()
override =
default;
377 AffineMap::mapType(),
390 Mat3d mat = mMatrix.getMat3();
391 const double det = mat.
det();
400 bool isEqual(
const MapBase& other)
const override {
return isEqualBase(*
this, other); }
405 if (!mMatrix.eq(other.mMatrix)) {
return false; }
406 if (!mMatrixInv.eq(other.mMatrixInv)) {
return false; }
410 bool operator!=(
const AffineMap& other)
const {
return !(*
this == other); }
414 mMatrix = other.mMatrix;
415 mMatrixInv = other.mMatrixInv;
417 mJacobianInv = other.mJacobianInv;
418 mDeterminant = other.mDeterminant;
419 mVoxelSize = other.mVoxelSize;
420 mIsDiagonal = other.mIsDiagonal;
421 mIsIdentity = other.mIsIdentity;
437 return applyInverseJacobian(in);
442 return mMatrixInv.transform3x3(in);
451 return Vec3d( m[ 0] * in[0] + m[ 1] * in[1] + m[ 2] * in[2],
452 m[ 4] * in[0] + m[ 5] * in[1] + m[ 6] * in[2],
453 m[ 8] * in[0] + m[ 9] * in[1] + m[10] * in[2] );
462 return mJacobianInv.
transpose()* m * mJacobianInv;
495 mMatrix.preRotate(axis, radians);
496 updateAcceleration();
501 updateAcceleration();
505 mMatrix.preTranslate(v);
506 updateAcceleration();
510 mMatrix.preShear(axis0, axis1, shear);
511 updateAcceleration();
520 mMatrix.postRotate(axis, radians);
521 updateAcceleration();
525 mMatrix.postScale(v);
526 updateAcceleration();
530 mMatrix.postTranslate(v);
531 updateAcceleration();
535 mMatrix.postShear(axis0, axis1, shear);
536 updateAcceleration();
542 void read(std::istream& is)
override { mMatrix.read(is); updateAcceleration(); }
544 void write(std::ostream& os)
const override { mMatrix.write(os); }
548 std::ostringstream
buffer;
549 buffer <<
" - mat4:\n" << mMatrix.str() << std::endl;
550 buffer <<
" - voxel dimensions: " << mVoxelSize << std::endl;
561 AffineMap::Ptr
getAffineMap()
const override {
return AffineMap::Ptr(
new AffineMap(*
this)); }
564 AffineMap::Ptr
inverse()
const {
return AffineMap::Ptr(
new AffineMap(mMatrixInv)); }
572 AffineMap::Ptr affineMap = getAffineMap();
573 affineMap->accumPreRotation(axis, radians);
578 AffineMap::Ptr affineMap = getAffineMap();
579 affineMap->accumPreTranslation(t);
580 return StaticPtrCast<MapBase, AffineMap>(affineMap);
584 AffineMap::Ptr affineMap = getAffineMap();
585 affineMap->accumPreScale(s);
586 return StaticPtrCast<MapBase, AffineMap>(affineMap);
590 AffineMap::Ptr affineMap = getAffineMap();
591 affineMap->accumPreShear(axis0, axis1, shear);
602 AffineMap::Ptr affineMap = getAffineMap();
603 affineMap->accumPostRotation(axis, radians);
608 AffineMap::Ptr affineMap = getAffineMap();
609 affineMap->accumPostTranslation(t);
610 return StaticPtrCast<MapBase, AffineMap>(affineMap);
614 AffineMap::Ptr affineMap = getAffineMap();
615 affineMap->accumPostScale(s);
616 return StaticPtrCast<MapBase, AffineMap>(affineMap);
620 AffineMap::Ptr affineMap = getAffineMap();
621 affineMap->accumPostShear(axis0, axis1, shear);
632 void updateAcceleration() {
633 Mat3d mat3 = mMatrix.getMat3();
634 mDeterminant = mat3.
det();
638 "Tried to initialize an affine transform from a nearly singular matrix");
640 mMatrixInv = mMatrix.inverse();
645 mVoxelSize(0) = (applyMap(
Vec3d(1,0,0)) - pos).
length();
646 mVoxelSize(1) = (applyMap(
Vec3d(0,1,0)) - pos).
length();
647 mVoxelSize(2) = (applyMap(
Vec3d(0,0,1)) - pos).
length();
658 bool mIsDiagonal, mIsIdentity;
676 mScaleValuesInverse(
Vec3d(1,1,1)),
677 mInvScaleSqr(1,1,1), mInvTwiceScale(0.5,0.5,0.5){}
682 mVoxelSize(
Vec3d(std::
abs(scale(0)),std::
abs(scale(1)), std::
abs(scale(2))))
684 double determinant = scale[0]* scale[1] * scale[2];
686 OPENVDB_THROW(ArithmeticError,
"Non-zero scale values required");
688 mScaleValuesInverse = 1.0 / mScaleValues;
689 mInvScaleSqr = mScaleValuesInverse * mScaleValuesInverse;
690 mInvTwiceScale = mScaleValuesInverse / 2;
695 mScaleValues(other.mScaleValues),
696 mVoxelSize(other.mVoxelSize),
697 mScaleValuesInverse(other.mScaleValuesInverse),
698 mInvScaleSqr(other.mInvScaleSqr),
699 mInvTwiceScale(other.mInvTwiceScale)
743 in.x() * mScaleValues.x(),
744 in.y() * mScaleValues.y(),
745 in.z() * mScaleValues.z());
751 in.x() * mScaleValuesInverse.x(),
752 in.y() * mScaleValuesInverse.y(),
753 in.z() * mScaleValuesInverse.z());
757 return applyJacobian(in);
765 return applyInverseJacobian(in);
770 return applyInverseMap(
in);
790 for (
int i = 0; i < 3; i++) {
791 tmp.
setRow(i,
in.row(i) * mScaleValuesInverse(i));
793 for (
int i = 0; i < 3; i++) {
794 tmp.
setCol(i, tmp.
col(i) * mScaleValuesInverse(i));
805 return mScaleValues.x() * mScaleValues.y() * mScaleValues.z();
827 void read(std::istream& is)
override
829 mScaleValues.read(is);
831 mScaleValuesInverse.read(is);
832 mInvScaleSqr.read(is);
833 mInvTwiceScale.read(is);
836 void write(std::ostream& os)
const override
838 mScaleValues.write(os);
839 mVoxelSize.write(os);
840 mScaleValuesInverse.write(os);
841 mInvScaleSqr.write(os);
842 mInvTwiceScale.write(os);
847 std::ostringstream
buffer;
848 buffer <<
" - scale: " << mScaleValues << std::endl;
849 buffer <<
" - voxel dimensions: " << mVoxelSize << std::endl;
853 bool isEqual(
const MapBase& other)
const override {
return isEqualBase(*
this, other); }
858 if (!mScaleValues.eq(other.mScaleValues)) {
return false; }
867 return AffineMap::Ptr(
new AffineMap(math::scale<Mat4d>(mScaleValues)));
877 AffineMap::Ptr affineMap = getAffineMap();
878 affineMap->accumPreRotation(axis, radians);
886 AffineMap::Ptr affineMap = getAffineMap();
887 affineMap->accumPreShear(axis0, axis1, shear);
898 AffineMap::Ptr affineMap = getAffineMap();
899 affineMap->accumPostRotation(axis, radians);
906 AffineMap::Ptr affineMap = getAffineMap();
907 affineMap->accumPostShear(axis0, axis1, shear);
913 Vec3d mScaleValues, mVoxelSize, mScaleValuesInverse, mInvScaleSqr, mInvTwiceScale;
929 ~UniformScaleMap()
override =
default;
938 const Vec3d& invScale = getInvScale();
946 UniformScaleMap::mapType(),
947 UniformScaleMap::create);
953 bool isEqual(
const MapBase& other)
const override {
return isEqualBase(*
this, other); }
956 bool operator!=(
const UniformScaleMap& other)
const {
return !(*
this == other); }
975 const Vec3d new_scale(v * mScaleValues);
1004 ~TranslationMap()
override =
default;
1012 return MapBase::Ptr(
new TranslationMap(-mTranslation));
1020 TranslationMap::mapType(),
1021 TranslationMap::create);
1045 return applyInverseJacobian(in);
1067 return applyIJC(mat);
1084 void read(std::istream& is)
override { mTranslation.read(is); }
1086 void write(std::ostream& os)
const override { mTranslation.write(os); }
1090 std::ostringstream
buffer;
1091 buffer <<
" - translation: " << mTranslation << std::endl;
1092 return buffer.str();
1095 bool isEqual(
const MapBase& other)
const override {
return isEqualBase(*
this, other); }
1100 return mTranslation.eq(other.mTranslation);
1103 bool operator!=(
const TranslationMap& other)
const {
return !(*
this == other); }
1111 AffineMap::Ptr affineMap(
new AffineMap(matrix));
1120 AffineMap::Ptr affineMap = getAffineMap();
1121 affineMap->accumPreRotation(axis, radians);
1127 return MapBase::Ptr(
new TranslationMap(t + mTranslation));
1134 AffineMap::Ptr affineMap = getAffineMap();
1135 affineMap->accumPreShear(axis0, axis1, shear);
1145 AffineMap::Ptr affineMap = getAffineMap();
1146 affineMap->accumPostRotation(axis, radians);
1152 return MapBase::Ptr(
new TranslationMap(t + mTranslation));
1159 AffineMap::Ptr affineMap = getAffineMap();
1160 affineMap->accumPostShear(axis0, axis1, shear);
1186 mTranslation(
Vec3d(0,0,0)),
1187 mScaleValues(
Vec3d(1,1,1)),
1188 mVoxelSize(
Vec3d(1,1,1)),
1189 mScaleValuesInverse(
Vec3d(1,1,1)),
1190 mInvScaleSqr(1,1,1),
1191 mInvTwiceScale(0.5,0.5,0.5)
1197 mTranslation(translate),
1198 mScaleValues(scale),
1199 mVoxelSize(std::
abs(scale(0)), std::
abs(scale(1)), std::
abs(scale(2)))
1201 const double determinant = scale[0]* scale[1] * scale[2];
1203 OPENVDB_THROW(ArithmeticError,
"Non-zero scale values required");
1205 mScaleValuesInverse = 1.0 / mScaleValues;
1206 mInvScaleSqr = mScaleValuesInverse * mScaleValuesInverse;
1207 mInvTwiceScale = mScaleValuesInverse / 2;
1212 mTranslation(translate.getTranslation()),
1214 mVoxelSize(std::
abs(mScaleValues(0)),
1215 std::
abs(mScaleValues(1)),
1216 std::
abs(mScaleValues(2))),
1217 mScaleValuesInverse(1.0 / scale.
getScale())
1219 mInvScaleSqr = mScaleValuesInverse * mScaleValuesInverse;
1220 mInvTwiceScale = mScaleValuesInverse / 2;
1225 mTranslation(other.mTranslation),
1226 mScaleValues(other.mScaleValues),
1227 mVoxelSize(other.mVoxelSize),
1228 mScaleValuesInverse(other.mScaleValuesInverse),
1229 mInvScaleSqr(other.mInvScaleSqr),
1230 mInvTwiceScale(other.mInvTwiceScale)
1243 mScaleValuesInverse, -mScaleValuesInverse * mTranslation));
1276 in.x() * mScaleValues.x() + mTranslation.x(),
1277 in.y() * mScaleValues.y() + mTranslation.y(),
1278 in.z() * mScaleValues.z() + mTranslation.z());
1284 (
in.x() - mTranslation.x() ) * mScaleValuesInverse.x(),
1285 (
in.y() - mTranslation.y() ) * mScaleValuesInverse.y(),
1286 (
in.z() - mTranslation.z() ) * mScaleValuesInverse.z());
1291 return applyJacobian(in);
1299 return applyInverseJacobian(in);
1304 return in * mScaleValuesInverse;
1316 return applyIJT(in);
1322 in.x() * mScaleValuesInverse.x(),
1323 in.y() * mScaleValuesInverse.y(),
1324 in.z() * mScaleValuesInverse.z());
1330 for (
int i=0; i<3; i++){
1331 tmp.
setRow(i,
in.row(i)*mScaleValuesInverse(i));
1333 for (
int i=0; i<3; i++){
1334 tmp.
setCol(i, tmp.
col(i)*mScaleValuesInverse(i));
1339 return applyIJC(in);
1346 return mScaleValues.x() * mScaleValues.y() * mScaleValues.z();
1366 void read(std::istream& is)
override
1368 mTranslation.read(is);
1369 mScaleValues.read(is);
1370 mVoxelSize.read(is);
1371 mScaleValuesInverse.read(is);
1372 mInvScaleSqr.read(is);
1373 mInvTwiceScale.read(is);
1376 void write(std::ostream& os)
const override
1378 mTranslation.write(os);
1379 mScaleValues.write(os);
1380 mVoxelSize.write(os);
1381 mScaleValuesInverse.write(os);
1382 mInvScaleSqr.write(os);
1383 mInvTwiceScale.write(os);
1388 std::ostringstream
buffer;
1389 buffer <<
" - translation: " << mTranslation << std::endl;
1390 buffer <<
" - scale: " << mScaleValues << std::endl;
1391 buffer <<
" - voxel dimensions: " << mVoxelSize << std::endl;
1392 return buffer.str();
1395 bool isEqual(
const MapBase& other)
const override {
return isEqualBase(*
this, other); }
1400 if (!mScaleValues.eq(other.mScaleValues)) {
return false; }
1401 if (!mTranslation.eq(other.mTranslation)) {
return false; }
1410 AffineMap::Ptr affineMap(
new AffineMap(math::scale<Mat4d>(mScaleValues)));
1411 affineMap->accumPostTranslation(mTranslation);
1420 AffineMap::Ptr affineMap = getAffineMap();
1421 affineMap->accumPreRotation(axis, radians);
1426 const Vec3d&
s = mScaleValues;
1427 const Vec3d scaled_trans( t.
x() * s.
x(),
1437 AffineMap::Ptr affineMap = getAffineMap();
1438 affineMap->accumPreShear(axis0, axis1, shear);
1448 AffineMap::Ptr affineMap = getAffineMap();
1449 affineMap->accumPostRotation(axis, radians);
1461 AffineMap::Ptr affineMap = getAffineMap();
1462 affineMap->accumPostShear(axis0, axis1, shear);
1468 Vec3d mTranslation, mScaleValues, mVoxelSize, mScaleValuesInverse,
1469 mInvScaleSqr, mInvTwiceScale;
1484 const Vec3d&
s = mScaleValues;
1485 const Vec3d scaled_trans( t.
x() * s.
x(),
1508 ~UniformScaleTranslateMap()
override =
default;
1517 const Vec3d& scaleInv = getInvScale();
1519 return MapBase::Ptr(
new UniformScaleTranslateMap(scaleInv[0], -scaleInv[0] * trans));
1530 UniformScaleTranslateMap::mapType(), UniformScaleTranslateMap::create);
1536 bool isEqual(
const MapBase& other)
const override {
return isEqualBase(*
this, other); }
1542 bool operator!=(
const UniformScaleTranslateMap& other)
const {
return !(*
this == other); }
1549 const Vec3d new_trans = this->getTranslation() + scale *
t;
1550 return MapBase::Ptr(
new UniformScaleTranslateMap(scale, new_trans));
1558 return MapBase::Ptr(
new UniformScaleTranslateMap(scale, this->getTranslation() + t));
1564 UniformScaleMap::postTranslate(
const Vec3d&
t)
const
1567 return MapBase::Ptr(
new UniformScaleTranslateMap(scale, t));
1572 UniformScaleMap::preTranslate(
const Vec3d& t)
const
1574 const double scale = this->
getScale().x();
1575 return MapBase::Ptr(
new UniformScaleTranslateMap(scale, scale*t));
1580 TranslationMap::preScale(
const Vec3d&
v)
const
1583 return MapBase::Ptr(
new UniformScaleTranslateMap(v[0], mTranslation));
1585 return MapBase::Ptr(
new ScaleTranslateMap(v, mTranslation));
1591 TranslationMap::postScale(
const Vec3d& v)
const
1594 return MapBase::Ptr(
new UniformScaleTranslateMap(v[0], v[0]*mTranslation));
1597 mTranslation.y()*v.y(),
1598 mTranslation.z()*v.z());
1607 const Vec3d new_scale( v * mScaleValues );
1609 return MapBase::Ptr(
new UniformScaleTranslateMap(new_scale[0], mTranslation));
1619 const Vec3d new_scale( v * mScaleValues );
1620 const Vec3d new_trans( mTranslation.
x()*v.
x(),
1621 mTranslation.
y()*v.
y(),
1622 mTranslation.
z()*v.
z() );
1625 return MapBase::Ptr(
new UniformScaleTranslateMap(new_scale[0], new_trans));
1653 mAffineMap = AffineMap(matrix);
1660 mAffineMap = AffineMap(matrix);
1667 OPENVDB_THROW(ArithmeticError,
"Matrix initializing unitary map was not unitary");
1672 mAffineMap = AffineMap(matrix);
1679 "4x4 Matrix initializing unitary map was not unitary: not invertible");
1684 "4x4 Matrix initializing unitary map was not unitary: not affine");
1689 "4x4 Matrix initializing unitary map was not unitary: had translation");
1694 "4x4 Matrix initializing unitary map was not unitary");
1697 mAffineMap = AffineMap(m);
1702 mAffineMap(other.mAffineMap)
1707 mAffineMap(*(first.getAffineMap()), *(second.getAffineMap()))
1711 ~UnitaryMap()
override =
default;
1720 return MapBase::Ptr(
new UnitaryMap(mAffineMap.getMat4().inverse()));
1728 UnitaryMap::mapType(),
1729 UnitaryMap::create);
1743 bool isEqual(
const MapBase& other)
const override {
return isEqualBase(*
this, other); }
1748 if (mAffineMap!=other.mAffineMap)
return false;
1752 bool operator!=(
const UnitaryMap& other)
const {
return !(*
this == other); }
1765 return applyInverseJacobian(in);
1770 return mAffineMap.applyInverseJacobian(in);
1778 return applyInverseMap(in);
1790 return applyIJC(in);
1796 double determinant()
const override {
return mAffineMap.determinant(); }
1807 void read(std::istream& is)
override
1809 mAffineMap.read(is);
1813 void write(std::ostream& os)
const override
1815 mAffineMap.write(os);
1820 std::ostringstream
buffer;
1821 buffer << mAffineMap.str();
1822 return buffer.str();
1826 return AffineMap::Ptr(
new AffineMap(mAffineMap));
1833 UnitaryMap
first(axis, radians);
1834 UnitaryMap::Ptr unitaryMap(
new UnitaryMap(first, *
this));
1835 return StaticPtrCast<MapBase, UnitaryMap>(unitaryMap);
1841 AffineMap::Ptr affineMap = getAffineMap();
1842 affineMap->accumPreTranslation(t);
1849 AffineMap::Ptr affineMap = getAffineMap();
1850 affineMap->accumPreScale(v);
1857 AffineMap::Ptr affineMap = getAffineMap();
1858 affineMap->accumPreShear(axis0, axis1, shear);
1866 UnitaryMap second(axis, radians);
1867 UnitaryMap::Ptr unitaryMap(
new UnitaryMap(*
this, second));
1868 return StaticPtrCast<MapBase, UnitaryMap>(unitaryMap);
1874 AffineMap::Ptr affineMap = getAffineMap();
1875 affineMap->accumPostTranslation(t);
1882 AffineMap::Ptr affineMap = getAffineMap();
1883 affineMap->accumPostScale(v);
1890 AffineMap::Ptr affineMap = getAffineMap();
1891 affineMap->accumPostShear(axis0, axis1, shear);
1896 AffineMap mAffineMap;
1929 MapBase(),mBBox(bb), mTaper(taper), mDepth(depth)
1941 mBBox(bb), mTaper(taper), mDepth(depth)
1943 if (!secondMap->isLinear() ) {
1945 "The second map in the Frustum transfrom must be linear");
1947 mSecondMap = *( secondMap->getAffineMap() );
1954 mTaper(other.mTaper),
1955 mDepth(other.mDepth),
1956 mSecondMap(other.mSecondMap),
1957 mHasSimpleAffine(other.mHasSimpleAffine)
1981 double z_near,
double depth,
1989 "The frustum depth must be non-zero and positive");
1991 if (!(up.
length() > 0)) {
1993 "The frustum height must be non-zero and positive");
1995 if (!(aspect > 0)) {
1997 "The frustum aspect ratio must be non-zero and positive");
2001 "The frustum up orientation must be perpendicular to into-frustum direction");
2004 double near_plane_height = 2 * up.
length();
2005 double near_plane_width = aspect * near_plane_height;
2010 mDepth = depth / near_plane_width;
2011 double gamma = near_plane_width / z_near;
2012 mTaper = 1./(mDepth*gamma + 1.);
2022 Mat4d scale = math::scale<Mat4d>(
2023 Vec3d(near_plane_width, near_plane_width, near_plane_width));
2027 Mat4d mat = scale * r2 * r1;
2030 mSecondMap = AffineMap(mat);
2035 ~NonlinearFrustumMap()
override =
default;
2048 "inverseMap() is not implemented for NonlinearFrustumMap");
2055 NonlinearFrustumMap::mapType(),
2056 NonlinearFrustumMap::create);
2077 const Vec3d e1(1,0,0);
2078 if (!applyMap(e1).eq(e1))
return false;
2080 const Vec3d e2(0,1,0);
2081 if (!applyMap(e2).eq(e2))
return false;
2083 const Vec3d e3(0,0,1);
2084 if (!applyMap(e3).eq(e3))
return false;
2089 bool isEqual(
const MapBase& other)
const override {
return isEqualBase(*
this, other); }
2093 if (mBBox!=other.mBBox)
return false;
2100 if (!mSecondMap.applyMap(e).eq(other.mSecondMap.applyMap(e)))
return false;
2103 if (!mSecondMap.applyMap(e).eq(other.mSecondMap.applyMap(e)))
return false;
2106 if (!mSecondMap.applyMap(e).eq(other.mSecondMap.applyMap(e)))
return false;
2109 if (!mSecondMap.applyMap(e).eq(other.mSecondMap.applyMap(e)))
return false;
2113 bool operator!=(
const NonlinearFrustumMap& other)
const {
return !(*
this == other); }
2118 return mSecondMap.applyMap(applyFrustumMap(in));
2124 return applyFrustumInverseMap(mSecondMap.applyInverseMap(in));
2133 Vec3d centered(isloc);
2134 centered = centered - mBBox.min();
2135 centered.
x() -= mXo;
2136 centered.
y() -= mYo;
2139 const double zprime = centered.
z()*mDepthOnLz;
2141 const double scale = (mGamma * zprime + 1.) / mLx;
2142 const double scale2 = mGamma * mDepthOnLz / mLx;
2144 const Vec3d tmp(scale * in.
x() + scale2 * centered.
x()* in.
z(),
2145 scale * in.
y() + scale2 * centered.
y()* in.
z(),
2146 mDepthOnLz * in.
z());
2148 return mSecondMap.applyJacobian(tmp);
2155 return mSecondMap.applyInverseJacobian(in);
2162 Vec3d centered(isloc);
2163 centered = centered - mBBox.min();
2164 centered.
x() -= mXo;
2165 centered.
y() -= mYo;
2168 const double zprime = centered.
z()*mDepthOnLz;
2170 const double scale = (mGamma * zprime + 1.) / mLx;
2171 const double scale2 = mGamma * mDepthOnLz / mLx;
2174 Vec3d out = mSecondMap.applyInverseJacobian(in);
2176 out.
x() = (out.
x() - scale2 * centered.
x() * out.
z() / mDepthOnLz) / scale;
2177 out.
y() = (out.
y() - scale2 * centered.
y() * out.
z() / mDepthOnLz) / scale;
2178 out.
z() = out.
z() / mDepthOnLz;
2186 const Vec3d tmp = mSecondMap.applyJT(in);
2189 Vec3d centered(isloc);
2190 centered = centered - mBBox.min();
2191 centered.
x() -= mXo;
2192 centered.
y() -= mYo;
2195 const double zprime = centered.
z()*mDepthOnLz;
2197 const double scale = (mGamma * zprime + 1.) / mLx;
2198 const double scale2 = mGamma * mDepthOnLz / mLx;
2200 return Vec3d(scale * tmp.
x(),
2202 scale2 * centered.
x()* tmp.
x() +
2203 scale2 * centered.
y()* tmp.
y() +
2204 mDepthOnLz * tmp.
z());
2208 return mSecondMap.applyJT(in);
2224 const Vec3d loc = applyFrustumMap(ijk);
2225 const double s = mGamma * loc.
z() + 1.;
2229 OPENVDB_THROW(ArithmeticError,
"Tried to evaluate the frustum transform"
2230 " at the singular focal point (e.g. camera)");
2233 const double sinv = 1.0/
s;
2234 const double pt0 = mLx * sinv;
2235 const double pt1 = mGamma * pt0;
2236 const double pt2 = pt1 * sinv;
2238 const Mat3d& jacinv = mSecondMap.getConstJacobianInv();
2242 for (
int j = 0; j < 3; ++j ) {
2243 gradE(0,j) = pt0 * jacinv(0,j) - pt2 * loc.
x()*jacinv(2,j);
2244 gradE(1,j) = pt0 * jacinv(1,j) - pt2 * loc.
y()*jacinv(2,j);
2245 gradE(2,j) = (1./mDepthOnLz) * jacinv(2,j);
2249 for (
int i = 0; i < 3; ++i) {
2250 result(i) = d1_is(0) * gradE(0,i) + d1_is(1) * gradE(1,i) + d1_is(2) * gradE(2,i);
2265 const Vec3d loc = applyFrustumMap(ijk);
2267 const double s = mGamma * loc.
z() + 1.;
2271 OPENVDB_THROW(ArithmeticError,
"Tried to evaluate the frustum transform"
2272 " at the singular focal point (e.g. camera)");
2276 const double sinv = 1.0/
s;
2277 const double pt0 = mLx * sinv;
2278 const double pt1 = mGamma * pt0;
2279 const double pt2 = pt1 * sinv;
2280 const double pt3 = pt2 * sinv;
2282 const Mat3d& jacinv = mSecondMap.getConstJacobianInv();
2288 for(
int j = 0; j < 3; j++) {
2289 for (
int k = 0; k < 3; k++) {
2291 const double pt4 = 2. * jacinv(2,j) * jacinv(2,k) * pt3;
2293 matE0(j,k) = -(jacinv(0,j) * jacinv(2,k) + jacinv(2,j) * jacinv(0,k)) * pt2 +
2296 matE1(j,k) = -(jacinv(1,j) * jacinv(2,k) + jacinv(2,j) * jacinv(1,k)) * pt2 +
2303 for (
int j = 0; j < 3; ++j ) {
2304 gradE(0,j) = pt0 * jacinv(0,j) - pt2 * loc.
x()*jacinv(2,j);
2305 gradE(1,j) = pt0 * jacinv(1,j) - pt2 * loc.
y()*jacinv(2,j);
2306 gradE(2,j) = (1./mDepthOnLz) * jacinv(2,j);
2312 for (
int m = 0;
m < 3; ++
m ) {
2313 for (
int n = 0;
n < 3; ++
n) {
2314 for (
int i = 0; i < 3; ++i ) {
2315 for (
int j = 0; j < 3; ++j) {
2316 result(
m,
n) += gradE(j,
m) * gradE(i,
n) * d2_is(i, j);
2322 for (
int m = 0;
m < 3; ++
m ) {
2323 for (
int n = 0;
n < 3; ++
n) {
2325 matE0(
m,
n) * d1_is(0) + matE1(
m,
n) * d1_is(1);
2333 double determinant()
const override {
return mSecondMap.determinant();}
2339 double s = mGamma * loc.
z() + 1.0;
2340 double frustum_determinant = s * s * mDepthOnLzLxLx;
2341 return mSecondMap.determinant() * frustum_determinant;
2347 const Vec3d loc( 0.5*(mBBox.min().x() + mBBox.max().x()),
2348 0.5*(mBBox.min().y() + mBBox.max().y()),
2351 return voxelSize(loc);
2361 Vec3d out, pos = applyMap(loc);
2362 out(0) = (applyMap(loc +
Vec3d(1,0,0)) - pos).
length();
2363 out(1) = (applyMap(loc +
Vec3d(0,1,0)) - pos).
length();
2364 out(2) = (applyMap(loc +
Vec3d(0,0,1)) - pos).
length();
2368 AffineMap::Ptr
getAffineMap()
const override {
return mSecondMap.getAffineMap(); }
2394 void read(std::istream& is)
override
2400 mBBox =
BBoxd(bb.
min().asVec3d(), bb.
max().asVec3d());
2405 is.read(reinterpret_cast<char*>(&mTaper),
sizeof(
double));
2406 is.read(reinterpret_cast<char*>(&mDepth),
sizeof(
double));
2413 OPENVDB_THROW(KeyError,
"Map " << type <<
" is not registered");
2419 mSecondMap = *(proxy->getAffineMap());
2424 void write(std::ostream& os)
const override
2427 os.write(reinterpret_cast<const char*>(&mTaper),
sizeof(
double));
2428 os.write(reinterpret_cast<const char*>(&mDepth),
sizeof(
double));
2431 mSecondMap.write(os);
2437 std::ostringstream
buffer;
2438 buffer <<
" - taper: " << mTaper << std::endl;
2439 buffer <<
" - depth: " << mDepth << std::endl;
2440 buffer <<
" SecondMap: "<< mSecondMap.type() << std::endl;
2441 buffer << mSecondMap.str() << std::endl;
2442 return buffer.str();
2450 new NonlinearFrustumMap(mBBox, mTaper, mDepth, mSecondMap.preRotate(radians, axis)));
2457 new NonlinearFrustumMap(mBBox, mTaper, mDepth, mSecondMap.preTranslate(t)));
2464 new NonlinearFrustumMap(mBBox, mTaper, mDepth, mSecondMap.preScale(s)));
2471 mBBox, mTaper, mDepth, mSecondMap.preShear(shear, axis0, axis1)));
2479 new NonlinearFrustumMap(mBBox, mTaper, mDepth, mSecondMap.postRotate(radians, axis)));
2486 new NonlinearFrustumMap(mBBox, mTaper, mDepth, mSecondMap.postTranslate(t)));
2493 new NonlinearFrustumMap(mBBox, mTaper, mDepth, mSecondMap.postScale(s)));
2500 mBBox, mTaper, mDepth, mSecondMap.postShear(shear, axis0, axis1)));
2507 mLx = mBBox.extents().x();
2508 mLy = mBBox.extents().y();
2509 mLz = mBBox.extents().z();
2512 OPENVDB_THROW(ArithmeticError,
"The index space bounding box"
2513 " must have at least two index points in each direction.");
2520 mGamma = (1./mTaper - 1) / mDepth;
2522 mDepthOnLz = mDepth/mLz;
2523 mDepthOnLzLxLx = mDepthOnLz/(mLx * mLx);
2526 mHasSimpleAffine =
true;
2527 Vec3d tmp = mSecondMap.voxelSize();
2530 if (!
isApproxEqual(tmp(0), tmp(1))) { mHasSimpleAffine =
false;
return; }
2531 if (!
isApproxEqual(tmp(0), tmp(2))) { mHasSimpleAffine =
false;
return; }
2540 if (!
isApproxEqual(tmp1.dot(tmp2), 0., 1.e-7)) { mHasSimpleAffine =
false;
return; }
2541 if (!
isApproxEqual(tmp2.dot(tmp3), 0., 1.e-7)) { mHasSimpleAffine =
false;
return; }
2542 if (!
isApproxEqual(tmp3.dot(tmp1), 0., 1.e-7)) { mHasSimpleAffine =
false;
return; }
2551 out = out - mBBox.min();
2556 out.z() *= mDepthOnLz;
2558 double scale = (mGamma * out.z() + 1.)/ mLx;
2567 Vec3d applyFrustumInverseMap(
const Vec3d& in)
const
2571 double invScale = mLx / (mGamma * out.z() + 1.);
2572 out.x() *= invScale;
2573 out.y() *= invScale;
2578 out.z() /= mDepthOnLz;
2581 out = out + mBBox.min();
2593 AffineMap mSecondMap;
2596 double mLx, mLy, mLz;
2597 double mXo, mYo, mGamma, mDepthOnLz, mDepthOnLzLxLx;
2600 bool mHasSimpleAffine;
2610 template<
typename FirstMapType,
typename SecondMapType>
2622 CompoundMap(
const FirstMapType&
f,
const SecondMapType&
s): mFirstMap(f), mSecondMap(s)
2624 updateAffineMatrix();
2628 mFirstMap(other.mFirstMap),
2629 mSecondMap(other.mSecondMap),
2630 mAffineMap(other.mAffineMap)
2636 return (FirstMapType::mapType() +
Name(
":") + SecondMapType::mapType());
2641 if (mFirstMap != other.mFirstMap)
return false;
2642 if (mSecondMap != other.mSecondMap)
return false;
2643 if (mAffineMap != other.mAffineMap)
return false;
2651 mFirstMap = other.mFirstMap;
2652 mSecondMap = other.mSecondMap;
2653 mAffineMap = other.mAffineMap;
2660 return mAffineMap.isIdentity();
2662 return mFirstMap.isIdentity()&&mSecondMap.isIdentity();
2668 return mAffineMap.isDiagonal();
2670 return mFirstMap.isDiagonal()&&mSecondMap.isDiagonal();
2677 AffineMap::Ptr affine(
new AffineMap(mAffineMap));
2681 "Constant affine matrix representation not possible for this nonlinear map");
2686 const FirstMapType&
firstMap()
const {
return mFirstMap; }
2687 const SecondMapType&
secondMap()
const {
return mSecondMap; }
2690 void setSecondMap(
const SecondMapType& second) { mSecondMap = second; updateAffineMatrix(); }
2694 mAffineMap.read(is);
2696 mSecondMap.read(is);
2700 mAffineMap.write(os);
2701 mFirstMap.write(os);
2702 mSecondMap.write(os);
2706 void updateAffineMatrix()
2710 AffineMap::Ptr
first = mFirstMap.getAffineMap();
2711 AffineMap::Ptr second= mSecondMap.getAffineMap();
2712 mAffineMap = AffineMap(*first, *second);
2716 FirstMapType mFirstMap;
2717 SecondMapType mSecondMap;
2719 AffineMap mAffineMap;
2726 #endif // OPENVDB_MATH_MAPS_HAS_BEEN_INCLUDED
bool isLinear() const OPENVDB_MAP_FUNC_SPECIFIER
Return true (a ScaleTranslateMap is always linear).
Mat3d applyIJC(const Mat3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian Curvature: zero for a linear map.
MapBase::Ptr postTranslate(const Vec3d &t) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropraite operation...
MapBase::Ptr copy() const override
Return a MapBase::Ptr to a deep copy of this map.
static bool isRegistered()
MapBase::Ptr postTranslate(const Vec3d &t) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropraite operation...
std::string str() const override
string serialization, useful for debuging
const Vec3d & getInvTwiceScale() const
Return 1/(2 scale). Used to optimize some finite difference calculations.
bool operator!=(const UniformScaleMap &other) const
MyType & operator=(const MyType &other)
MapBase::Ptr preRotate(double radians, Axis axis) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropriate operation...
Vec3d applyInverseMap(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the pre-image of under the map.
bool isInvertible(const MatType &m)
Determine if a matrix is invertible.
double determinant(const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the product of the scale values, ignores argument.
MapBase::Ptr postRotate(double radians, Axis axis) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation to the ...
ScaleTranslateMap(const Vec3d &scale, const Vec3d &translate)
void setToRotation(const Quat< T > &q)
Set this matrix to the rotation matrix specified by the quaternion.
bool isType() const
Return true if this map is of concrete type MapT (e.g., AffineMap).
UnitaryMap(const UnitaryMap &first, const UnitaryMap &second)
Creates the composition of two maps, each of which could be a composition. In the case that each comp...
Vec3d applyJT(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian Transpose of the map applied to in.
AffineMap(const Mat4d &m)
double getDepth() const
Return the unscaled frustm depth.
static void registerMap()
GLenum GLenum GLenum GLenum GLenum scale
bool operator!=(const ScaleTranslateMap &other) const
double determinant(const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the product of the scale values, ignores argument.
Vec3d applyInverseJacobian(const Vec3d &in, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation) ...
bool operator==(const ScaleTranslateMap &other) const
void accumPreTranslation(const Vec3d &v)
Modify the existing affine map by pre-applying the given operation.
bool normalize(T eps=T(1.0e-7))
this = normalized this
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropraite operation...
Vec3d applyMap(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the image of in under the map.
MatType shear(Axis axis0, Axis axis1, typename MatType::value_type shear)
Set the matrix to a shear along axis0 by a fraction of axis1.
MapBase::Ptr postRotate(double radians, Axis axis) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropriate operation...
Threadsafe singleton object for accessing the map type-name dictionary. Associates a map type-name wi...
Vec3d voxelSize(const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the lengths of the images of the segments (0,0,0) − 1,0,0), (0,0,0) − (0,1,0) and (0,0,0) − (0,0,1).
#define OPENVDB_MAP_CLASS_SPECIFIER
bool operator==(const NonlinearFrustumMap &other) const
void write(std::ostream &os) const override
write serialization
OIIO_UTIL_API bool copy(string_view from, string_view to, std::string &err)
Vec3d voxelSize() const OPENVDB_MAP_FUNC_SPECIFIER
Return the lengths of the images of the segments (0,0,0) − 1,0,0), (0,0,0) − (0,1,0) and (0,0,0) − (0,0,1).
MapBase::Ptr preScale(const Vec3d &) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation to the ...
std::map< Name, MapBase::MapFactory > MapDictionary
IMF_EXPORT IMATH_NAMESPACE::V3f direction(const IMATH_NAMESPACE::Box2i &dataWindow, const IMATH_NAMESPACE::V2f &pixelPosition)
UnitaryMap()
default constructor makes an Idenity.
MapBase::Ptr preRotate(double radians, Axis axis) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation...
Mat3d applyIJC(const Mat3d &mat, const Vec3d &, const Vec3d &) const override
UnitaryMap(const Vec3d &axis, double radians)
Mat3d applyIJC(const Mat3d &in, const Vec3d &, const Vec3d &) const override
Vec3< T > col(int j) const
Get jth column, e.g. Vec3d v = m.col(0);.
Mat3< T > getMat3() const
A specialized Affine transform that scales along the principal axis the scaling need not be uniform i...
bool hasSimpleAffine() const
Return true if the second map is a uniform scale, Rotation and translation.
const Mat4d & getConstMat4() const
AffineMap(const Mat3d &m)
const AffineMap & secondMap() const
Return MapBase::Ptr& to the second map.
bool operator==(const UniformScaleMap &other) const
static MapBase::Ptr create()
Return a MapBase::Ptr to a new AffineMap.
Mat3d applyIJC(const Mat3d &in) const override
Return the Jacobian Curvature: zero for a linear map.
Vec3d applyJT(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian Transpose of the map applied to in.
Mat4d getMat4() const
Return the matrix representation of this AffineMap.
bool isIdentity(const MatType &m)
Determine if a matrix is an identity matrix.
#define OPENVDB_USE_VERSION_NAMESPACE
MapBase::Ptr postTranslate(const Vec3d &) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation to the ...
AffineMap::Ptr getAffineMap() const
Vec3d applyIJT(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the transpose of the inverse Jacobian of the map applied to in.
void setTaper(double t)
set the taper value, the ratio of nearplane width / far plane width
MapBase::Ptr preScale(const Vec3d &v) const override
Return a MapBase::Ptr to a new map that is the result of prepending the given scale.
static bool isRegistered()
AffineMap::Ptr inverse() const
Return AffineMap::Ptr to the inverse of this map.
const SecondMapType & secondMap() const
SharedPtr< const MapBase > ConstPtr
MapBase::Ptr postRotate(double radians, Axis axis=X_AXIS) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropraite operation...
static bool isRegistered(const Name &)
Return true if the given map type name is registered.
Vec3d applyJacobian(const Vec3d &in, const Vec3d &) const override
Return the Jacobian of the map applied to in.
void accumPreShear(Axis axis0, Axis axis1, double shear)
Modify the existing affine map by pre-applying the given operation.
double determinant(const Vec3d &loc) const override
bool isLinear() const OPENVDB_MAP_FUNC_SPECIFIER
Return true (a ScaleMap is always linear).
MapBase::Ptr postScale(const Vec3d &) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation to the ...
const Vec3d & getTranslation() const
Return the translation vector.
void accumPostRotation(Axis axis, double radians)
Modify the existing affine map by post-applying the given operation.
OPENVDB_API Mat4d approxInverse(const Mat4d &mat)
Returns the left pseudoInverse of the input matrix when the 3x3 part is symmetric otherwise it zeros ...
T dot(const Vec3< T > &v) const
Dot product.
void setToRotation(Axis axis, T angle)
Sets the matrix to a rotation about the given axis.
void read(T &in, bool &v)
void accumPostTranslation(const Vec3d &v)
Modify the existing affine map by post-applying the given operation.
bool isScaleTranslate() const
Return true if the map is equivalent to a ScaleTranslateMap.
ScaleTranslateMap(const ScaleTranslateMap &other)
Tolerance for floating-point comparison.
void setTranslation(const Vec3< T > &t)
Mat3d applyIJC(const Mat3d &mat) const override
Return the Jacobian Curvature: zero for a linear map.
void read(std::istream &is)
Unserialize this bounding box from the given stream.
double getTaper() const
Return the taper value.
Vec3d applyInverseMap(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the pre-image of in under the map.
NonlinearFrustumMap(const NonlinearFrustumMap &other)
static MapBase::Ptr createMap(const Name &)
Create a new map of the given (registered) type name.
const Coord & min() const
Vec3d applyJacobian(const Vec3d &in, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian of the map applied to in.
const FirstMapType & firstMap() const
const Vec3d & getScale() const
Returns the scale values.
Vec3d applyIJT(const Vec3d &in, const Vec3d &) const override
Return the transpose of the inverse Jacobian of the map applied to in.
std::string str() const override
string serialization, useful for debuging
void read(std::istream &is)
Vec3d applyJacobian(const Vec3d &in, const Vec3d &isloc) const override
Return the Jacobian defined at isloc applied to in.
OPENVDB_API SharedPtr< PolarDecomposedMap > createPolarDecomposedMap(const Mat3d &m)
Decomposes a general linear into translation following polar decomposition.
Mat3d applyIJC(const Mat3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian Curvature: zero for a linear map.
std::shared_ptr< T > SharedPtr
ImageBuf OIIO_API pow(const ImageBuf &A, cspan< float > B, ROI roi={}, int nthreads=0)
static MapBase::Ptr create()
Return a MapBase::Ptr to a new ScaleTranslateMap.
MapBase::Ptr preTranslate(const Vec3d &) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation to the ...
Mat3 transpose() const
returns transpose of this
static void registerMap()
UnitaryMap(const UnitaryMap &other)
bool operator==(const MyType &other) const
GLint GLint GLsizei GLsizei GLsizei depth
const Vec3d & getInvScale() const
Return 1/(scale)
bool operator==(const UniformScaleTranslateMap &other) const
bool hasUniformScale() const OPENVDB_MAP_FUNC_SPECIFIER
Return true if the scale values have the same magnitude (eg. -1, 1, -1 would be a rotation)...
bool operator!=(const ScaleMap &other) const
Mat3d applyIJC(const Mat3d &in, const Vec3d &, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
ScaleTranslateMap(const ScaleMap &scale, const TranslationMap &translate)
static void registerMap()
const Vec3d & getInvScaleSqr() const
Return the square of the scale. Used to optimize some finite difference calculations.
OPENVDB_API SharedPtr< FullyDecomposedMap > createFullyDecomposedMap(const Mat4d &m)
General decomposition of a Matrix into a Unitary (e.g. rotation) following a Symmetric (e...
bool operator==(const ScaleMap &other) const
Mat3d applyIJC(const Mat3d &in, const Vec3d &, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Name type() const override
Return the name of this map's concrete type (e.g., "AffineMap").
A general linear transform using homogeneous coordinates to perform rotation, scaling, shear and translation.
NonlinearFrustumMap(const BBoxd &bb, double taper, double depth, const MapBase::Ptr &secondMap)
Constructor that takes an index-space bounding box to be mapped into a frustum with a given depth and...
UnitaryMap(const Mat4d &m)
const Vec3d & getInvScaleSqr() const
Return the square of the scale. Used to optimize some finite difference calculations.
bool operator!=(const UniformScaleTranslateMap &other) const
bool isApproxEqual(const Type &a, const Type &b, const Type &tolerance)
Return true if a is equal to b to within the given tolerance.
MapBase::Ptr copy() const override
Return a MapBase::Ptr to a deep copy of this map.
#define OPENVDB_MAP_FUNC_SPECIFIER
Vec3d voxelSize() const OPENVDB_MAP_FUNC_SPECIFIER
Return the absolute values of the scale values.
Vec3d applyInverseJacobian(const Vec3d &in, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation) ...
MapBase::Ptr preRotate(double radians, Axis axis=X_AXIS) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation...
void read(std::istream &is) override
read serialization
CompoundMap(const FirstMapType &f, const SecondMapType &s)
bool operator!=(const AffineMap &other) const
void accumPostShear(Axis axis0, Axis axis1, double shear)
Modify the existing affine map by post-applying the given operation.
UniformScaleTranslateMap(const UniformScaleMap &scale, const TranslationMap &translate)
bool isDiagonal(const MatType &mat)
Determine if a matrix is diagonal.
TranslationMap(const Vec3d &t)
UniformScaleMap(const UniformScaleMap &other)
Mat3 inverse(T tolerance=0) const
static MapBase::Ptr create()
Return a MapBase::Ptr to a new ScaleMap.
Vec3d applyJT(const Vec3d &in) const override
Return the Jacobian Transpose of the map applied to in.
AffineMap::Ptr getAffineMap() const override
Return AffineMap::Ptr to a deep copy of the current AffineMap.
void accumPreScale(const Vec3d &v)
Modify the existing affine map by pre-applying the given operation.
GA_API const UT_StringHolder trans
void writeString(std::ostream &os, const Name &name)
bool hasUniformScale() const override
Return false ( test if this is unitary with translation )
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
void accumPostScale(const Vec3d &v)
Modify the existing affine map by post-applying the given operation.
AffineMap::Ptr getAffineMap() const override
Return AffineMap::Ptr to an AffineMap equivalent to *this.
MapBase::Ptr postScale(const Vec3d &v) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropraite operation...
float Round(float x)
Return x rounded to the nearest integer.
MapBase::Ptr postRotate(double radians, Axis axis) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropraite operation...
MapBase::Ptr inverseMap() const override
Return a new map representing the inverse of this map.
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
bool operator!=(const MyType &other) const
void setCol(int j, const Vec3< T > &v)
Set jth column to vector v.
double determinant() const override
Return the determinant of the Jacobian.
std::string str() const override
string serialization, useful for debugging
Vec3d applyJacobian(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian of the map applied to in.
void read(std::istream &is)
Unserialize this bounding box from the given stream.
GLsizei const GLchar *const * string
ScaleMap(const Vec3d &scale)
Vec3d applyJT(const Vec3d &in, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian Transpose of the map applied to in.
const Vec3d & getTranslation() const
Returns the translation.
MapBase::Ptr preTranslate(const Vec3d &t) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation...
const Coord & max() const
Vec3d voxelSize(const Vec3d &loc) const override
Returns the lengths of the images of the three segments from loc to loc + (1,0,0), from loc to loc + (0,1,0) and from loc to loc + (0,0,1)
Vec3d applyInverseJacobian(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation) ...
void write(std::ostream &os) const
void setMat3(const Mat3< T > &m)
Set upper left to a Mat3.
Vec3d applyInverseJacobian(const Vec3d &in, const Vec3d &) const override
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation) ...
bool operator!=(const UnitaryMap &other) const
void write(std::ostream &os) const override
write serialization
Axis-aligned bounding box of signed integer coordinates.
bool isScale() const
Return true if the map is equivalent to a ScaleMap.
MapBase::Ptr preRotate(double radians, Axis axis) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation to the ...
const BBoxd & getBBox() const
Return the bounding box that defines the frustum in pre-image space.
MapBase::Ptr postScale(const Vec3d &s) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropraite operation...
bool isUnitary(const MatType &m)
Determine if a matrix is unitary (i.e., rotation or reflection).
UniformScaleTranslateMap(double scale, const Vec3d &translate)
Vec3d applyMap(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the image of under the map.
Vec3d applyIJT(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the transpose of the inverse Jacobian of the map applied to in.
T det() const
Determinant of matrix.
SharedPtr< FullyDecomposedMap > createDecomposedMap()
on-demand decomposition of the affine map
AffineMap::Ptr getAffineMap() const override
Return a AffineMap equivalent to this map.
AffineMap(const AffineMap &other)
MapBase::Ptr preShear(double shear, Axis axis0, Axis axis1) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation to the ...
Vec3d applyInverseJacobian(const Vec3d &in, const Vec3d &isloc) const override
Return the Inverse Jacobian defined at isloc of the map applied to in.
static bool isEqualBase(const MapT &self, const MapBase &other)
Name type() const override
Return the name of this map's concrete type (e.g., "AffineMap").
Vec3d applyInverseMap(const Vec3d &in) const override
Return the pre-image of in under the map.
bool hasUniformScale() const OPENVDB_MAP_FUNC_SPECIFIER
Return true if the values have the same magitude (eg. -1, 1, -1 would be a rotation).
Vec3d applyJT(const Vec3d &in, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian Transpose of the map applied to in.
bool isIdentity() const
Return true if the underlying matrix is approximately an identity.
double determinant() const OPENVDB_MAP_FUNC_SPECIFIER
Return the product of the scale values.
static const Mat3< double > & zero()
Predefined constant for zero matrix.
Vec3d applyInverseJacobian(const Vec3d &in) const override
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation) ...
ScaleMap(const ScaleMap &other)
bool operator==(const UnitaryMap &other) const
TranslationMap(const TranslationMap &other)
Vec3d applyJT(const Vec3d &in, const Vec3d &) const override
MapBase::Ptr preShear(double shear, Axis axis0, Axis axis1) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation...
bool operator==(const AffineMap &other) const
void setFirstMap(const FirstMapType &first)
Vec3d voxelSize() const override
Return the lengths of the images of the segments (0,0,0)-(1,0,0), (0,0,0)-(0,1,0) and (0...
GLuint GLsizei GLsizei * length
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
bool hasTranslation(const Mat4< T > &m)
double determinant() const OPENVDB_MAP_FUNC_SPECIFIER
Return the product of the scale values.
MatType scale(const Vec3< typename MatType::value_type > &s)
Return a matrix that scales by s.
MapBase::Ptr postScale(const Vec3d &v) const override
Return a MapBase::Ptr to a new map that is the result of appending the given scale.
UnitaryMap(Axis axis, double radians)
UniformScaleTranslateMap(const UniformScaleTranslateMap &other)
Vec3d applyIJT(const Vec3d &in, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the transpose of the inverse Jacobian of the map applied to in.
void setRow(int i, const Vec3< T > &v)
Set ith row to vector v.
CompoundMap< CompoundMap< UnitaryMap, ScaleMap >, UnitaryMap > SpectralDecomposedMap
SharedPtr< const MyType > ConstPtr
A specialized Affine transform that scales along the principal axis the scaling need not be uniform i...
Vec3d applyIJT(const Vec3d &in, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the transpose of the inverse Jacobian of the map applied to in.
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Return a MapBase::Ptr to a new map that is the result of postfixing the appropraite operation...
NonlinearFrustumMap(const BBoxd &bb, double taper, double depth)
Constructor that takes an index-space bounding box to be mapped into a frustum with a given depth and...
bool isLinear() const override
Return true (an AffineMap is always linear).
T & x()
Reference to the component, e.g. v.x() = 4.5f;.
bool operator!=(const TranslationMap &other) const
Vec3d applyJacobian(const Vec3d &in, const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian of the map applied to in.
Mat3d applyIJC(const Mat3d &d2_is, const Vec3d &d1_is, const Vec3d &ijk) const override
Vec3d voxelSize(const Vec3d &) const override
Return the lengths of the images of the segments (0,0,0)-(1,0,0), (0,0,0)-(0,1,0) and (0...
bool operator!=(const NonlinearFrustumMap &other) const
OPENVDB_API SharedPtr< MapBase > simplify(SharedPtr< AffineMap > affine)
reduces an AffineMap to a ScaleMap or a ScaleTranslateMap when it can
Name type() const override
Return the name of this map's concrete type (e.g., "AffineMap").
Vec4< T0 > transform(const Vec4< T0 > &v) const
Transform a Vec4 by post-multiplication.
math::BBox< Vec3d > BBoxd
void write(std::ostream &os) const override
write serialization
Vec3< typename MatType::value_type > getScale(const MatType &mat)
Return a Vec3 representing the lengths of the passed matrix's upper 3×3's rows.
static const Mat4< double > & identity()
Predefined constant for identity matrix.
Name readString(std::istream &is)
MapBase::Ptr preShear(double shear, Axis axis0, Axis axis1) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation...
Vec3d applyJT(const Vec3d &in, const Vec3d &isloc) const override
Return the Jacobian Transpose of the map applied to vector in at indexloc.
GLsizei const GLfloat * value
CompoundMap(const MyType &other)
Vec3d applyJacobian(const Vec3d &in) const override
Return the Jacobian of the map applied to in.
void read(std::istream &is) override
read serialization
Vec3d applyIJT(const Vec3d &in) const override
Return the transpose of the inverse Jacobian of the map applied to in.
Mat3d applyIJC(const Mat3d &m) const override
Return the Jacobian Curvature: zero for a linear map.
static bool isRegistered()
MapBase::Ptr copy() const override
Return a MapBase::Ptr to a deep copy of this map.
bool operator==(const TranslationMap &other) const
void accumPreRotation(Axis axis, double radians)
Modify the existing affine map by pre-applying the given operation.
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation to the ...
const Vec3d & getInvTwiceScale() const
Return 1/(2 scale). Used to optimize some finite difference calculations.
void read(std::istream &is) override
read serialization
const Vec3d & getScale() const
Return the scale values that define the map.
IMATH_INTERNAL_NAMESPACE_HEADER_ENTER IMATH_HOSTDEVICE constexpr T abs(T a) IMATH_NOEXCEPT
UniformScaleTranslateMap()
double determinant(const Vec3d &) const override
Return the determinant of the Jacobian, ignores argument.
Vec3d applyInverseJacobian(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation) ...
const Vec3d & getInvScale() const
Return 1/(scale)
PUGI__FN char_t * translate(char_t *buffer, const char_t *from, const char_t *to, size_t to_length)
UnitaryMap(const Mat3d &m)
void setDepth(double d)
set the frustum depth: distance between near and far plane = frustm depth * frustm x-width ...
Vec3d applyJacobian(const Vec3d &in) const OPENVDB_MAP_FUNC_SPECIFIER
Return the Jacobian of the map applied to in.
bool isDiagonal() const
Return true if the underylying matrix is diagonal.
void write(T &out, bool v)
static void registerMap(const Name &, MapBase::MapFactory)
Register a map type along with a factory function.
Abstract base class for maps.
OIIO_FORCEINLINE OIIO_HOSTDEVICE T radians(T deg)
Convert degrees to radians.
bool isAffine(const Mat4< T > &m)
const Mat3d & getConstJacobianInv() const
OPENVDB_API SharedPtr< SymmetricMap > createSymmetricMap(const Mat3d &m)
Utility methods.
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
MapBase::Ptr preScale(const Vec3d &v) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation...
MapBase::Ptr inverseMap() const override
Return a new map representing the inverse of this map.
UniformScaleMap(double scale)
OPENVDB_API uint32_t getFormatVersion(std::ios_base &)
Return the file format version number associated with the given input stream.
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
Vec3d applyMap(const Vec3d &in) const override
Return the image of in under the map.
MapBase::Ptr preTranslate(const Vec3d &t) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation...
Vec3d voxelSize(const Vec3d &) const OPENVDB_MAP_FUNC_SPECIFIER
Return the absolute values of the scale values, ignores argument.
AffineMap(const AffineMap &first, const AffineMap &second)
constructor that merges the matrixes for two affine maps
NonlinearFrustumMap(const Vec3d &position, const Vec3d &direction, const Vec3d &up, double aspect, double z_near, double depth, Coord::ValueType x_count, Coord::ValueType z_count)
Constructor from a camera frustum.
Mat4 inverse(T tolerance=0) const
T length() const
Length of the vector.
AffineMap & operator=(const AffineMap &other)
MapBase::Ptr inverseMap() const override
Return a new map representing the inverse of this map.
#define OPENVDB_THROW(exception, message)
MapBase::Ptr preScale(const Vec3d &s) const override
Return a MapBase::Ptr to a new map that is the result of prepending the appropraite operation...
Vec3d applyIJT(const Vec3d &d1_is, const Vec3d &ijk) const override
void setSecondMap(const SecondMapType &second)