6#ifndef OPENVDB_MATH_MAPS_HAS_BEEN_INCLUDED 
    7#define OPENVDB_MATH_MAPS_HAS_BEEN_INCLUDED 
   35class ScaleTranslateMap;
 
   37class UniformScaleTranslateMap;
 
   40class NonlinearFrustumMap;
 
   42template<
typename T1, 
typename T2> 
class CompoundMap;
 
   79template<
typename T> 
struct is_scale                  { 
static const bool value = 
false; };
 
  150    template<
typename MapT> 
bool isType()
 const { 
return this->
type() == MapT::mapType(); }
 
  187    virtual void read(std::istream&) = 0;
 
  188    virtual void write(std::ostream&) 
const = 0;
 
  190    virtual std::string 
str() 
const = 0;
 
  249    template<
typename MapT>
 
  252        return other.
isType<MapT>() && (self == *
static_cast<const MapT*
>(&other));
 
 
 
  302        mMatrix(
Mat4d::identity()),
 
  303        mMatrixInv(
Mat4d::identity()),
 
  304        mJacobianInv(
Mat3d::identity()),
 
  306        mVoxelSize(
Vec3d(1,1,1)),
 
 
  318        updateAcceleration();
 
 
  325                "Tried to initialize an affine transform from a non-affine 4x4 matrix");
 
  327        updateAcceleration();
 
 
  332        mMatrix(other.mMatrix),
 
  333        mMatrixInv(other.mMatrixInv),
 
  334        mJacobianInv(other.mJacobianInv),
 
  335        mDeterminant(other.mDeterminant),
 
  336        mVoxelSize(other.mVoxelSize),
 
  337        mIsDiagonal(other.mIsDiagonal),
 
  338        mIsIdentity(other.mIsIdentity)
 
 
  344        mMatrix(first.mMatrix * second.mMatrix)
 
  346        updateAcceleration();
 
 
  376        Mat3d mat = mMatrix.getMat3();
 
  377        const double det = mat.
det();
 
  381            mat *= (1.0 / pow(std::abs(det), 1.0/3.0));
 
 
  391        if (!mMatrix.eq(other.mMatrix)) { 
return false; }
 
  392        if (!mMatrixInv.eq(other.mMatrixInv))  { 
return false; }
 
 
  400        mMatrix = other.mMatrix;
 
  401        mMatrixInv = other.mMatrixInv;
 
  403        mJacobianInv = other.mJacobianInv;
 
  404        mDeterminant = other.mDeterminant;
 
  405        mVoxelSize = other.mVoxelSize;
 
  406        mIsDiagonal  = other.mIsDiagonal;
 
  407        mIsIdentity  = other.mIsIdentity;
 
 
  428        return mMatrixInv.transform3x3(in);
 
 
  437        return Vec3d( m[ 0] * in[0] + m[ 1] * in[1] + m[ 2] * in[2],
 
  438                      m[ 4] * in[0] + m[ 5] * in[1] + m[ 6] * in[2],
 
  439                      m[ 8] * in[0] + m[ 9] * in[1] + m[10] * in[2] );
 
 
  448        return mJacobianInv.
transpose()* m * mJacobianInv;
 
 
  481        mMatrix.preRotate(axis, radians);
 
  482        updateAcceleration();
 
 
  487        updateAcceleration();
 
 
  491        mMatrix.preTranslate(v);
 
  492        updateAcceleration();
 
 
  496        mMatrix.preShear(axis0, axis1, 
shear);
 
  497        updateAcceleration();
 
 
  506        mMatrix.postRotate(axis, radians);
 
  507        updateAcceleration();
 
 
  511        mMatrix.postScale(v);
 
  512        updateAcceleration();
 
 
  516        mMatrix.postTranslate(v);
 
  517        updateAcceleration();
 
 
  521        mMatrix.postShear(axis0, axis1, 
shear);
 
  522        updateAcceleration();
 
 
  528    void read(std::istream& is)
 override { mMatrix.read(is); updateAcceleration(); }
 
  530    void write(std::ostream& os)
 const override { mMatrix.write(os); }
 
  532    std::string 
str()
 const override 
  534        std::ostringstream buffer;
 
  535        buffer << 
" - mat4:\n" << mMatrix.str() << std::endl;
 
  536        buffer << 
" - voxel dimensions: " << mVoxelSize << std::endl;
 
 
  559        affineMap->accumPreRotation(axis, radians);
 
 
  565        affineMap->accumPreTranslation(t);
 
 
  571        affineMap->accumPreScale(s);
 
 
  577        affineMap->accumPreShear(axis0, axis1, 
shear);
 
 
  589        affineMap->accumPostRotation(axis, radians);
 
 
  595        affineMap->accumPostTranslation(t);
 
 
  601        affineMap->accumPostScale(s);
 
 
  607        affineMap->accumPostShear(axis0, axis1, 
shear);
 
 
  618    void updateAcceleration() {
 
  619        Mat3d mat3 = mMatrix.getMat3();
 
  620        mDeterminant = mat3.
det();
 
  624                "Tried to initialize an affine transform from a nearly singular matrix");
 
  626        mMatrixInv = mMatrix.inverse();
 
  631        mVoxelSize(0) = (applyMap(
Vec3d(1,0,0)) - pos).length();
 
  632        mVoxelSize(1) = (applyMap(
Vec3d(0,1,0)) - pos).length();
 
  633        mVoxelSize(2) = (applyMap(
Vec3d(0,0,1)) - pos).length();
 
  644    bool   mIsDiagonal, mIsIdentity;
 
 
  662                mScaleValuesInverse(
Vec3d(1,1,1)),
 
  663                mInvScaleSqr(1,1,1), mInvTwiceScale(0.5,0.5,0.5){}
 
 
  674        mScaleValuesInverse = 1.0 / mScaleValues;
 
  675        mInvScaleSqr = mScaleValuesInverse * mScaleValuesInverse;
 
  676        mInvTwiceScale = mScaleValuesInverse / 2;
 
 
  681        mScaleValues(other.mScaleValues),
 
  682        mVoxelSize(other.mVoxelSize),
 
  683        mScaleValuesInverse(other.mScaleValuesInverse),
 
  684        mInvScaleSqr(other.mInvScaleSqr),
 
  685        mInvTwiceScale(other.mInvTwiceScale)
 
 
  719            std::abs(mScaleValues.x()), std::abs(mScaleValues.y()), 
double(5e-7));
 
  721            std::abs(mScaleValues.x()), std::abs(mScaleValues.z()), 
double(5e-7));
 
 
  729            in.x() * mScaleValues.x(),
 
  730            in.y() * mScaleValues.y(),
 
  731            in.z() * mScaleValues.z());
 
 
  737            in.x() * mScaleValuesInverse.x(),
 
  738            in.y() * mScaleValuesInverse.y(),
 
  739            in.z() * mScaleValuesInverse.z());
 
 
  776        for (
int i = 0; i < 3; i++) {
 
  777            tmp.
setRow(i, in.row(i) * mScaleValuesInverse(i));
 
  779        for (
int i = 0; i < 3; i++) {
 
  780            tmp.
setCol(i, tmp.
col(i) * mScaleValuesInverse(i));
 
 
  791        return mScaleValues.x() * mScaleValues.y() * mScaleValues.z();
 
 
  813    void read(std::istream& is)
 override 
  815        mScaleValues.read(is);
 
  817        mScaleValuesInverse.read(is);
 
  818        mInvScaleSqr.read(is);
 
  819        mInvTwiceScale.read(is);
 
 
  822    void write(std::ostream& os)
 const override 
  824        mScaleValues.write(os);
 
  825        mVoxelSize.write(os);
 
  826        mScaleValuesInverse.write(os);
 
  827        mInvScaleSqr.write(os);
 
  828        mInvTwiceScale.write(os);
 
 
  831    std::string 
str()
 const override 
  833        std::ostringstream buffer;
 
  834        buffer << 
" - scale: " << mScaleValues << std::endl;
 
  835        buffer << 
" - voxel dimensions: " << mVoxelSize << std::endl;
 
 
  844        if (!mScaleValues.eq(other.mScaleValues)) { 
return false; }
 
 
  864        affineMap->accumPreRotation(axis, radians);
 
 
  873        affineMap->accumPreShear(axis0, axis1, 
shear);
 
 
  885        affineMap->accumPostRotation(axis, radians);
 
 
  893        affineMap->accumPostShear(axis0, axis1, 
shear);
 
 
  899    Vec3d mScaleValues, mVoxelSize, mScaleValuesInverse, mInvScaleSqr, mInvTwiceScale;
 
 
  960    const Vec3d new_scale(v * mScaleValues);
 
 
 1068    void read(std::istream& is)
 override { mTranslation.read(is); }
 
 1070    void write(std::ostream& os)
 const override { mTranslation.write(os); }
 
 1072    std::string 
str()
 const override 
 1074        std::ostringstream buffer;
 
 1075        buffer << 
" - translation: " << mTranslation << std::endl;
 
 1076        return buffer.str();
 
 
 1084        return mTranslation.eq(other.mTranslation);
 
 
 1105        affineMap->accumPreRotation(axis, radians);
 
 
 1119        affineMap->accumPreShear(axis0, axis1, 
shear);
 
 
 1130        affineMap->accumPostRotation(axis, radians);
 
 
 1144        affineMap->accumPostShear(axis0, axis1, 
shear);
 
 
 
 1170        mTranslation(
Vec3d(0,0,0)),
 
 1171        mScaleValues(
Vec3d(1,1,1)),
 
 1172        mVoxelSize(
Vec3d(1,1,1)),
 
 1173        mScaleValuesInverse(
Vec3d(1,1,1)),
 
 1174        mInvScaleSqr(1,1,1),
 
 1175        mInvTwiceScale(0.5,0.5,0.5)
 
 
 1181        mTranslation(translate),
 
 1182        mScaleValues(
scale),
 
 1189        mScaleValuesInverse = 1.0 / mScaleValues;
 
 1190        mInvScaleSqr = mScaleValuesInverse * mScaleValuesInverse;
 
 1191        mInvTwiceScale = mScaleValuesInverse / 2;
 
 
 1198        mVoxelSize(
std::abs(mScaleValues(0)),
 
 1199                         std::abs(mScaleValues(1)),
 
 1200                         std::abs(mScaleValues(2))),
 
 1203        mInvScaleSqr = mScaleValuesInverse * mScaleValuesInverse;
 
 1204        mInvTwiceScale = mScaleValuesInverse / 2;
 
 
 1209        mTranslation(other.mTranslation),
 
 1210        mScaleValues(other.mScaleValues),
 
 1211        mVoxelSize(other.mVoxelSize),
 
 1212        mScaleValuesInverse(other.mScaleValuesInverse),
 
 1213        mInvScaleSqr(other.mInvScaleSqr),
 
 1214        mInvTwiceScale(other.mInvTwiceScale)
 
 
 1227            mScaleValuesInverse, -mScaleValuesInverse * mTranslation));
 
 
 1250            std::abs(mScaleValues.x()), std::abs(mScaleValues.y()), 
double(5e-7));
 
 1252            std::abs(mScaleValues.x()), std::abs(mScaleValues.z()), 
double(5e-7));
 
 
 1260            in.x() * mScaleValues.x() + mTranslation.x(),
 
 1261            in.y() * mScaleValues.y() + mTranslation.y(),
 
 1262            in.z() * mScaleValues.z() + mTranslation.z());
 
 
 1268            (in.x() - mTranslation.x() ) * mScaleValuesInverse.x(),
 
 1269            (in.y() - mTranslation.y() ) * mScaleValuesInverse.y(),
 
 1270            (in.z() - mTranslation.z() ) * mScaleValuesInverse.z());
 
 
 1288        return in * mScaleValuesInverse;
 
 
 1306            in.x() * mScaleValuesInverse.x(),
 
 1307            in.y() * mScaleValuesInverse.y(),
 
 1308            in.z() * mScaleValuesInverse.z());
 
 
 1314        for (
int i=0; i<3; i++){
 
 1315            tmp.
setRow(i, in.row(i)*mScaleValuesInverse(i));
 
 1317        for (
int i=0; i<3; i++){
 
 1318            tmp.
setCol(i, tmp.
col(i)*mScaleValuesInverse(i));
 
 
 1330        return mScaleValues.x() * mScaleValues.y() * mScaleValues.z();
 
 
 1350    void read(std::istream& is)
 override 
 1352        mTranslation.read(is);
 
 1353        mScaleValues.read(is);
 
 1354        mVoxelSize.read(is);
 
 1355        mScaleValuesInverse.read(is);
 
 1356        mInvScaleSqr.read(is);
 
 1357        mInvTwiceScale.read(is);
 
 
 1360    void write(std::ostream& os)
 const override 
 1362        mTranslation.write(os);
 
 1363        mScaleValues.write(os);
 
 1364        mVoxelSize.write(os);
 
 1365        mScaleValuesInverse.write(os);
 
 1366        mInvScaleSqr.write(os);
 
 1367        mInvTwiceScale.write(os);
 
 
 1370    std::string 
str()
 const override 
 1372        std::ostringstream buffer;
 
 1373        buffer << 
" - translation: " << mTranslation << std::endl;
 
 1374        buffer << 
" - scale: " << mScaleValues << std::endl;
 
 1375        buffer << 
" - voxel dimensions: " << mVoxelSize << std::endl;
 
 1376        return buffer.str();
 
 
 1384        if (!mScaleValues.eq(other.mScaleValues)) { 
return false; }
 
 1385        if (!mTranslation.eq(other.mTranslation)) { 
return false; }
 
 
 1395        affineMap->accumPostTranslation(mTranslation);
 
 
 1405        affineMap->accumPreRotation(axis, radians);
 
 
 1410        const Vec3d& s = mScaleValues;
 
 1411        const Vec3d scaled_trans( t.
x() * s.
x(),
 
 
 1422        affineMap->accumPreShear(axis0, axis1, 
shear);
 
 
 1433        affineMap->accumPostRotation(axis, radians);
 
 
 1446        affineMap->accumPostShear(axis0, axis1, 
shear);
 
 
 1452    Vec3d mTranslation, mScaleValues, mVoxelSize, mScaleValuesInverse,
 
 1453        mInvScaleSqr, mInvTwiceScale;
 
 
 1468    const Vec3d& s = mScaleValues;
 
 1469    const Vec3d scaled_trans( t.
x() * s.
x(),
 
 
 1579        const Vec3d trans(mTranslation.x()*v.
x(),
 
 1580                          mTranslation.y()*v.
y(),
 
 1581                          mTranslation.z()*v.
z());
 
 
 1590    const Vec3d new_scale( v * mScaleValues );
 
 
 1602    const Vec3d new_scale( v * mScaleValues );
 
 1603    const Vec3d new_trans( mTranslation.x()*v.
x(),
 
 1604                           mTranslation.y()*v.
y(),
 
 1605                           mTranslation.z()*v.
z() );
 
 
 1661                "4x4 Matrix initializing unitary map was not unitary: not invertible");
 
 1666                "4x4 Matrix initializing unitary map was not unitary: not affine");
 
 1671                "4x4 Matrix initializing unitary map was not unitary: had translation");
 
 1676                "4x4 Matrix initializing unitary map was not unitary");
 
 
 1684        mAffineMap(other.mAffineMap)
 
 
 1730        if (mAffineMap!=other.mAffineMap)  
return false;
 
 
 1752        return mAffineMap.applyInverseJacobian(in);
 
 
 1778    double determinant()
 const override { 
return mAffineMap.determinant(); }
 
 1789    void read(std::istream& is)
 override 
 1791        mAffineMap.read(is);
 
 
 1795    void write(std::ostream& os)
 const override 
 1797        mAffineMap.write(os);
 
 
 1800    std::string 
str()
 const override 
 1802        std::ostringstream buffer;
 
 1803        buffer << mAffineMap.str();
 
 1804        return buffer.str();
 
 
 1824        affineMap->accumPreTranslation(t);
 
 
 1832        affineMap->accumPreScale(v);
 
 
 1840        affineMap->accumPreShear(axis0, axis1, 
shear);
 
 
 1857        affineMap->accumPostTranslation(t);
 
 
 1865        affineMap->accumPostScale(v);
 
 
 1873        affineMap->accumPostShear(axis0, axis1, 
shear);
 
 
 
 1910        MapBase(),mBBox(bb), mTaper(taper), mDepth(depth)
 
 
 1922        mBBox(bb), mTaper(taper), mDepth(depth)
 
 1925              OPENVDB_THROW(ArithmeticError,
 
 1926                "The second map in the Frustum transfrom must be linear");
 
 1928        mSecondMap = *( 
secondMap->getAffineMap() );
 
 
 1935        mTaper(other.mTaper),
 
 1936        mDepth(other.mDepth),
 
 1937        mSecondMap(other.mSecondMap),
 
 1938        mHasSimpleAffine(other.mHasSimpleAffine)
 
 
 1959                        const Vec3d& direction,
 
 1962                        double z_near, 
double depth,
 
 1970                "The frustum depth must be non-zero and positive");
 
 1972        if (!(up.
length() > 0)) {
 
 1974                "The frustum height must be non-zero and positive");
 
 1976        if (!(aspect > 0)) {
 
 1978                "The frustum aspect ratio  must be non-zero and positive");
 
 1982                "The frustum up orientation must be perpendicular to into-frustum direction");
 
 1985        double near_plane_height = 2 * up.
length();
 
 1986        double near_plane_width = aspect * near_plane_height;
 
 1991        mDepth = depth / near_plane_width;  
 
 1992        double gamma = near_plane_width / z_near;
 
 1993        mTaper = 1./(mDepth*gamma + 1.);
 
 1995        Vec3d direction_unit = direction;
 
 2004            Vec3d(near_plane_width, near_plane_width, near_plane_width));
 
 
 2029            "inverseMap() is not implemented for NonlinearFrustumMap");
 
 
 2058        const Vec3d e1(1,0,0);
 
 2059        if (!
applyMap(e1).eq(e1)) 
return false;
 
 2061        const Vec3d e2(0,1,0);
 
 2062        if (!
applyMap(e2).eq(e2)) 
return false;
 
 2064        const Vec3d e3(0,0,1);
 
 2065        if (!
applyMap(e3).eq(e3)) 
return false;
 
 
 2074        if (mBBox!=other.mBBox) 
return false;
 
 2081        if (!mSecondMap.applyMap(e).eq(other.mSecondMap.
applyMap(e))) 
return false;
 
 2084        if (!mSecondMap.applyMap(e).eq(other.mSecondMap.
applyMap(e))) 
return false;
 
 2087        if (!mSecondMap.applyMap(e).eq(other.mSecondMap.
applyMap(e))) 
return false;
 
 2090        if (!mSecondMap.applyMap(e).eq(other.mSecondMap.
applyMap(e))) 
return false;
 
 
 2099        return mSecondMap.applyMap(applyFrustumMap(in));
 
 
 2105        return applyFrustumInverseMap(mSecondMap.applyInverseMap(in));
 
 
 2114        Vec3d centered(isloc);
 
 2115        centered = centered - mBBox.min();
 
 2116        centered.
x() -= mXo;
 
 2117        centered.
y() -= mYo;
 
 2120        const double zprime = centered.
z()*mDepthOnLz;
 
 2122        const double scale = (mGamma * zprime + 1.) / mLx;
 
 2123        const double scale2 = mGamma * mDepthOnLz / mLx;
 
 2125        const Vec3d tmp(
scale * in.
x() + scale2 * centered.
x()* in.
z(),
 
 2126                        scale * in.
y() + scale2 * centered.
y()* in.
z(),
 
 2127                        mDepthOnLz * in.
z());
 
 2129        return mSecondMap.applyJacobian(tmp);
 
 
 2136        return mSecondMap.applyInverseJacobian(in);
 
 
 2143        Vec3d centered(isloc);
 
 2144        centered = centered - mBBox.min();
 
 2145        centered.
x() -= mXo;
 
 2146        centered.
y() -= mYo;
 
 2149        const double zprime = centered.
z()*mDepthOnLz;
 
 2151        const double scale = (mGamma * zprime + 1.) / mLx;
 
 2152        const double scale2 = mGamma * mDepthOnLz / mLx;
 
 2155        Vec3d out = mSecondMap.applyInverseJacobian(in);
 
 2157        out.
x() = (out.
x() - scale2 * centered.
x() * out.
z() / mDepthOnLz) / 
scale;
 
 2158        out.
y() = (out.
y() - scale2 * centered.
y() * out.
z() / mDepthOnLz) / 
scale;
 
 2159        out.
z() = out.
z() / mDepthOnLz;
 
 
 2167        const Vec3d tmp = mSecondMap.applyJT(in);
 
 2170        Vec3d centered(isloc);
 
 2171        centered = centered - mBBox.min();
 
 2172        centered.
x() -= mXo;
 
 2173        centered.
y() -= mYo;
 
 2176        const double zprime = centered.
z()*mDepthOnLz;
 
 2178        const double scale = (mGamma * zprime + 1.) / mLx;
 
 2179        const double scale2 = mGamma * mDepthOnLz / mLx;
 
 2183                     scale2 * centered.
x()* tmp.
x() +
 
 2184                     scale2 * centered.
y()* tmp.
y() +
 
 2185                     mDepthOnLz * tmp.
z());
 
 
 2189        return mSecondMap.applyJT(in);
 
 
 2205        const Vec3d loc = applyFrustumMap(ijk);
 
 2206        const double s = mGamma * loc.
z() + 1.;
 
 2211                " at the singular focal point (e.g. camera)");
 
 2214        const double sinv = 1.0/s;        
 
 2215        const double pt0 = mLx * sinv;    
 
 2216        const double pt1 = mGamma * pt0;  
 
 2217        const double pt2 = pt1 * sinv;    
 
 2219        const Mat3d& jacinv = mSecondMap.getConstJacobianInv();
 
 2223        for (
int j = 0; j < 3; ++j ) {
 
 2224            gradE(0,j) =  pt0 * jacinv(0,j) -  pt2 * loc.
x()*jacinv(2,j);
 
 2225            gradE(1,j) =  pt0 * jacinv(1,j) -  pt2 * loc.
y()*jacinv(2,j);
 
 2226            gradE(2,j) = (1./mDepthOnLz) * jacinv(2,j);
 
 2230        for (
int i = 0; i < 3; ++i) {
 
 2231            result(i) = d1_is(0) * gradE(0,i) + d1_is(1) * gradE(1,i) + d1_is(2) * gradE(2,i);
 
 
 2246        const Vec3d loc = applyFrustumMap(ijk);
 
 2248        const double s =  mGamma * loc.
z()  + 1.;
 
 2253                " at the singular focal point (e.g. camera)");
 
 2257        const double sinv = 1.0/s;     
 
 2258        const double pt0 = mLx * sinv;   
 
 2259        const double pt1 = mGamma * pt0;   
 
 2260        const double pt2 = pt1 * sinv;   
 
 2261        const double pt3 = pt2 * sinv;   
 
 2263        const Mat3d& jacinv = mSecondMap.getConstJacobianInv();
 
 2269        for(
int j = 0; j < 3; j++) {
 
 2270            for (
int k = 0; k < 3; k++) {
 
 2272                const double pt4 =  2. * jacinv(2,j) * jacinv(2,k) * pt3;
 
 2274                matE0(j,k) = -(jacinv(0,j) * jacinv(2,k) + jacinv(2,j) * jacinv(0,k)) * pt2 +
 
 2277                matE1(j,k) = -(jacinv(1,j) * jacinv(2,k) + jacinv(2,j) * jacinv(1,k)) * pt2 +
 
 2284        for (
int j = 0; j < 3; ++j ) {
 
 2285            gradE(0,j) =  pt0 * jacinv(0,j) -  pt2 * loc.
x()*jacinv(2,j);
 
 2286            gradE(1,j) =  pt0 * jacinv(1,j) -  pt2 * loc.
y()*jacinv(2,j);
 
 2287            gradE(2,j) = (1./mDepthOnLz) * jacinv(2,j);
 
 2293        for (
int m = 0; m < 3; ++m ) {
 
 2294            for ( 
int n = 0; n < 3; ++n) {
 
 2295                for (
int i = 0; i < 3; ++i ) {
 
 2296                    for (
int j = 0; j < 3; ++j) {
 
 2297                        result(m, n) += gradE(j, m) * gradE(i, n) * d2_is(i, j);
 
 2303         for (
int m = 0; m < 3; ++m ) {
 
 2304            for ( 
int n = 0; n < 3; ++n) {
 
 2306                    matE0(m, n) * d1_is(0) + matE1(m, n) * d1_is(1);
 
 
 2314    double determinant()
 const override {
return mSecondMap.determinant();} 
 
 2320        double s = mGamma * loc.
z() + 1.0;
 
 2321        double frustum_determinant = s * s * mDepthOnLzLxLx;
 
 2322        return mSecondMap.determinant() * frustum_determinant;
 
 
 2328        const Vec3d loc( 0.5*(mBBox.min().x() + mBBox.max().x()),
 
 2329                         0.5*(mBBox.min().y() + mBBox.max().y()),
 
 
 2375    void read(std::istream& is)
 override 
 2386        is.read(
reinterpret_cast<char*
>(&mTaper), 
sizeof(
double));
 
 2387        is.read(
reinterpret_cast<char*
>(&mDepth), 
sizeof(
double));
 
 2400        mSecondMap = *(proxy->getAffineMap());
 
 
 2405    void write(std::ostream& os)
 const override 
 2408        os.write(
reinterpret_cast<const char*
>(&mTaper), 
sizeof(
double));
 
 2409        os.write(
reinterpret_cast<const char*
>(&mDepth), 
sizeof(
double));
 
 2412        mSecondMap.write(os);
 
 
 2416    std::string 
str()
 const override 
 2418        std::ostringstream buffer;
 
 2419        buffer << 
" - taper: " << mTaper << std::endl;
 
 2420        buffer << 
" - depth: " << mDepth << std::endl;
 
 2421        buffer << 
" SecondMap: "<< mSecondMap.type() << std::endl;
 
 2422        buffer << mSecondMap.str() << std::endl;
 
 2423        return buffer.str();
 
 
 2452            mBBox, mTaper, mDepth, mSecondMap.preShear(
shear, axis0, axis1)));
 
 
 2481            mBBox, mTaper, mDepth, mSecondMap.postShear(
shear, axis0, axis1)));
 
 
 2488        mLx = mBBox.extents().x();
 
 2489        mLy = mBBox.extents().y();
 
 2490        mLz = mBBox.extents().z();
 
 2494                " must have at least two index points in each direction.");
 
 2501        mGamma = (1./mTaper - 1) / mDepth;
 
 2503        mDepthOnLz = mDepth/mLz;
 
 2504        mDepthOnLzLxLx = mDepthOnLz/(mLx * mLx);
 
 2507        mHasSimpleAffine = 
true;
 
 2508        Vec3d tmp = mSecondMap.voxelSize();
 
 2511        if (!isApproxEqual(tmp(0), tmp(1))) { mHasSimpleAffine = 
false; 
return; }
 
 2512        if (!isApproxEqual(tmp(0), tmp(2))) { mHasSimpleAffine = 
false; 
return; }
 
 2514        Vec3d trans = mSecondMap.applyMap(Vec3d(0,0,0));
 
 2516        Vec3d tmp1 = mSecondMap.applyMap(Vec3d(1,0,0)) - trans;
 
 2517        Vec3d tmp2 = mSecondMap.applyMap(Vec3d(0,1,0)) - trans;
 
 2518        Vec3d tmp3 = mSecondMap.applyMap(Vec3d(0,0,1)) - trans;
 
 2521        if (!isApproxEqual(tmp1.dot(tmp2), 0., 1.e-7)) { mHasSimpleAffine  = 
false; 
return; }
 
 2522        if (!
isApproxEqual(tmp2.dot(tmp3), 0., 1.e-7)) { mHasSimpleAffine  = 
false; 
return; }
 
 2523        if (!
isApproxEqual(tmp3.dot(tmp1), 0., 1.e-7)) { mHasSimpleAffine  = 
false; 
return; }
 
 2526    Vec3d applyFrustumMap(
const Vec3d& in)
 const 
 2532        out = out - mBBox.min();
 
 2537        out.z() *= mDepthOnLz;
 
 2539        double scale = (mGamma * out.z() + 1.)/ mLx;
 
 2548    Vec3d applyFrustumInverseMap(
const Vec3d& in)
 const 
 2552        double invScale = mLx / (mGamma * out.z() + 1.);
 
 2553        out.x() *= invScale;
 
 2554        out.y() *= invScale;
 
 2559        out.z() /= mDepthOnLz;
 
 2562        out = out +  mBBox.min();
 
 2574    AffineMap mSecondMap;
 
 2577    double mLx, mLy, mLz;
 
 2578    double mXo, mYo, mGamma, mDepthOnLz, mDepthOnLzLxLx;
 
 2581    bool mHasSimpleAffine;
 
 
 2591template<
typename FirstMapType, 
typename SecondMapType>
 
 2603    CompoundMap(
const FirstMapType& f, 
const SecondMapType& s): mFirstMap(f), mSecondMap(s)
 
 2605        updateAffineMatrix();
 
 
 2609        mFirstMap(other.mFirstMap),
 
 2610        mSecondMap(other.mSecondMap),
 
 2611        mAffineMap(other.mAffineMap)
 
 
 2617        return (FirstMapType::mapType() + 
Name(
":") + SecondMapType::mapType());
 
 
 2622        if (mFirstMap != other.mFirstMap)   
return false;
 
 2623        if (mSecondMap != other.mSecondMap) 
return false;
 
 2624        if (mAffineMap != other.mAffineMap) 
return false;
 
 
 2632        mFirstMap = other.mFirstMap;
 
 2633        mSecondMap = other.mSecondMap;
 
 2634        mAffineMap = other.mAffineMap;
 
 
 2641            return mAffineMap.isIdentity();
 
 2643            return mFirstMap.isIdentity()&&mSecondMap.isIdentity();
 
 
 2649            return mAffineMap.isDiagonal();
 
 2651            return mFirstMap.isDiagonal()&&mSecondMap.isDiagonal();
 
 
 2662                "Constant affine matrix representation not possible for this nonlinear map");
 
 
 2667    const FirstMapType& 
firstMap()
 const { 
return mFirstMap; }
 
 2668    const SecondMapType& 
secondMap()
 const {
return mSecondMap; }
 
 2670    void setFirstMap(
const FirstMapType& first) { mFirstMap = first; updateAffineMatrix(); }
 
 2671    void setSecondMap(
const SecondMapType& second) { mSecondMap = second; updateAffineMatrix(); }
 
 2675        mAffineMap.read(is);
 
 2677        mSecondMap.read(is);
 
 
 2681        mAffineMap.write(os);
 
 2682        mFirstMap.write(os);
 
 2683        mSecondMap.write(os);
 
 
 2687    void updateAffineMatrix()
 
 2693            mAffineMap = 
AffineMap(*first, *second);
 
 2697    FirstMapType   mFirstMap;
 
 2698    SecondMapType  mSecondMap;
 
 2700    AffineMap      mAffineMap;
 
 
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
Definition Exceptions.h:56
Definition Exceptions.h:59
Definition Exceptions.h:61
A general linear transform using homogeneous coordinates to perform rotation, scaling,...
Definition Maps.h:296
MapBase::Ptr postScale(const Vec3d &s) const override
Definition Maps.h:598
void accumPostShear(Axis axis0, Axis axis1, double shear)
Definition Maps.h:519
static void registerMap()
Definition Maps.h:360
AffineMap()
Definition Maps.h:301
void write(std::ostream &os) const override
write serialization
Definition Maps.h:530
Vec3d voxelSize(const Vec3d &) const override
Definition Maps.h:462
AffineMap(const Mat3d &m)
Definition Maps.h:313
bool isDiagonal() const
Return true if the underylying matrix is diagonal.
Definition Maps.h:468
Vec3d applyJT(const Vec3d &in, const Vec3d &) const override
Definition Maps.h:433
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Definition Maps.h:604
MapBase::Ptr preShear(double shear, Axis axis0, Axis axis1) const override
Definition Maps.h:574
void accumPostRotation(Axis axis, double radians)
Modify the existing affine map by post-applying the given operation.
Definition Maps.h:504
void accumPreShear(Axis axis0, Axis axis1, double shear)
Definition Maps.h:494
MapBase::Ptr postTranslate(const Vec3d &t) const override
Definition Maps.h:592
Vec3d applyIJT(const Vec3d &in) const override
Return the transpose of the inverse Jacobian of the map applied to in.
Definition Maps.h:445
AffineMap(const AffineMap &first, const AffineMap &second)
constructor that merges the matrixes for two affine maps
Definition Maps.h:343
Mat4d getMat4() const
Return the matrix representation of this AffineMap.
Definition Maps.h:613
Name type() const override
Return the name of this map's concrete type (e.g., "AffineMap").
Definition Maps.h:367
AffineMap::Ptr getAffineMap() const override
Return AffineMap::Ptr to a deep copy of the current AffineMap.
Definition Maps.h:547
double determinant(const Vec3d &) const override
Return the determinant of the Jacobian, ignores argument.
Definition Maps.h:454
bool operator!=(const AffineMap &other) const
Definition Maps.h:396
bool hasUniformScale() const override
Return false ( test if this is unitary with translation )
Definition Maps.h:374
bool operator==(const AffineMap &other) const
Definition Maps.h:388
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.
Definition Maps.h:586
Vec3d applyJT(const Vec3d &in) const override
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:435
double determinant() const override
Return the determinant of the Jacobian.
Definition Maps.h:456
Vec3d applyJacobian(const Vec3d &in, const Vec3d &) const override
Return the Jacobian of the map applied to in.
Definition Maps.h:416
Mat3d applyIJC(const Mat3d &in, const Vec3d &, const Vec3d &) const override
Definition Maps.h:450
MapBase::Ptr copy() const override
Return a MapBase::Ptr to a deep copy of this map.
Definition Maps.h:354
Vec3d applyJacobian(const Vec3d &in) const override
Return the Jacobian of the map applied to in.
Definition Maps.h:418
std::string str() const override
string serialization, useful for debugging
Definition Maps.h:532
AffineMap::Ptr inverse() const
Return AffineMap::Ptr to the inverse of this map.
Definition Maps.h:550
bool isLinear() const override
Return true (an AffineMap is always linear).
Definition Maps.h:371
const Mat3d & getConstJacobianInv() const
Definition Maps.h:615
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)
Definition Maps.h:422
Vec3d applyInverseJacobian(const Vec3d &in) const override
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation)
Definition Maps.h:427
MapBase::Ptr preTranslate(const Vec3d &t) const override
Definition Maps.h:562
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,...
Definition Maps.h:461
MapBase::Ptr preScale(const Vec3d &s) const override
Definition Maps.h:568
static bool isRegistered()
Definition Maps.h:358
bool isScaleTranslate() const
Return true if the map is equivalent to a ScaleTranslateMap.
Definition Maps.h:472
AffineMap(const AffineMap &other)
Definition Maps.h:330
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.
Definition Maps.h:556
const Mat4d & getConstMat4() const
Definition Maps.h:614
AffineMap & operator=(const AffineMap &other)
Definition Maps.h:398
Mat3d applyIJC(const Mat3d &m) const override
Return the Jacobian Curvature: zero for a linear map.
Definition Maps.h:447
Vec3d applyIJT(const Vec3d &in, const Vec3d &) const override
Return the transpose of the inverse Jacobian of the map applied to in.
Definition Maps.h:443
Vec3d applyMap(const Vec3d &in) const override
Return the image of in under the map.
Definition Maps.h:411
MapBase::Ptr inverseMap() const override
Return a new map representing the inverse of this map.
Definition Maps.h:356
bool isIdentity() const
Return true if the underlying matrix is approximately an identity.
Definition Maps.h:466
SharedPtr< const AffineMap > ConstPtr
Definition Maps.h:299
void read(std::istream &is) override
read serialization
Definition Maps.h:528
void accumPreRotation(Axis axis, double radians)
Modify the existing affine map by pre-applying the given operation.
Definition Maps.h:479
bool isScale() const
Return true if the map is equivalent to a ScaleMap.
Definition Maps.h:470
Vec3d applyInverseMap(const Vec3d &in) const override
Return the pre-image of in under the map.
Definition Maps.h:413
void accumPreScale(const Vec3d &v)
Definition Maps.h:484
void accumPreTranslation(const Vec3d &v)
Definition Maps.h:489
static MapBase::Ptr create()
Return a MapBase::Ptr to a new AffineMap.
Definition Maps.h:352
SharedPtr< FullyDecomposedMap > createDecomposedMap()
on-demand decomposition of the affine map
Definition Maps.h:541
SharedPtr< AffineMap > Ptr
Definition Maps.h:298
void accumPostScale(const Vec3d &v)
Definition Maps.h:509
~AffineMap() override=default
static Name mapType()
Definition Maps.h:368
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
Definition Maps.h:386
void accumPostTranslation(const Vec3d &v)
Definition Maps.h:514
AffineMap(const Mat4d &m)
Definition Maps.h:321
Creates the composition of two maps, each of which could be a composition. In the case that each comp...
Definition Maps.h:2593
CompoundMap< UnitaryMap, TranslationMap > MyType
Definition Maps.h:2595
SharedPtr< MyType > Ptr
Definition Maps.h:2597
const SecondMapType & secondMap() const
Definition Maps.h:2668
const FirstMapType & firstMap() const
Definition Maps.h:2667
void setSecondMap(const SecondMapType &second)
Definition Maps.h:2671
bool isDiagonal() const
Definition Maps.h:2647
SharedPtr< const MyType > ConstPtr
Definition Maps.h:2598
void write(std::ostream &os) const
Definition Maps.h:2679
void setFirstMap(const FirstMapType &first)
Definition Maps.h:2670
AffineMap::Ptr getAffineMap() const
Definition Maps.h:2655
CompoundMap()
Definition Maps.h:2601
bool operator==(const MyType &other) const
Definition Maps.h:2620
bool operator!=(const MyType &other) const
Definition Maps.h:2628
Name type() const
Definition Maps.h:2614
CompoundMap(const FirstMapType &f, const SecondMapType &s)
Definition Maps.h:2603
bool isIdentity() const
Definition Maps.h:2638
MyType & operator=(const MyType &other)
Definition Maps.h:2630
static Name mapType()
Definition Maps.h:2615
CompoundMap(const MyType &other)
Definition Maps.h:2608
void read(std::istream &is)
Definition Maps.h:2673
Axis-aligned bounding box of signed integer coordinates.
Definition Coord.h:252
const Coord & min() const
Definition Coord.h:324
const Coord & max() const
Definition Coord.h:325
void read(std::istream &is)
Unserialize this bounding box from the given stream.
Definition Coord.h:499
Int32 ValueType
Definition Coord.h:33
Vec3d asVec3d() const
Definition Coord.h:144
Abstract base class for maps.
Definition Maps.h:135
virtual Vec3d voxelSize() const =0
Method to return the local size of a voxel. When a location is specified as an argument,...
virtual Vec3d applyInverseMap(const Vec3d &in) const =0
static bool isEqualBase(const MapT &self, const MapBase &other)
Definition Maps.h:250
virtual Vec3d applyMap(const Vec3d &in) const =0
virtual SharedPtr< AffineMap > getAffineMap() const =0
SharedPtr< MapBase > Ptr
Definition Maps.h:137
bool isType() const
Return true if this map is of concrete type MapT (e.g., AffineMap).
Definition Maps.h:150
virtual double determinant() const =0
virtual MapBase::Ptr preShear(double shear, Axis axis0, Axis axis1) const =0
virtual Mat3d applyIJC(const Mat3d &m) const =0
virtual Vec3d applyJT(const Vec3d &in) const =0
Apply the Jacobian transpose of this map to a vector. For a linear map this is equivalent to applying...
virtual std::string str() const =0
virtual Mat3d applyIJC(const Mat3d &m, const Vec3d &v, const Vec3d &domainPos) const =0
virtual Vec3d applyJT(const Vec3d &in, const Vec3d &domainPos) const =0
virtual MapBase::Ptr copy() const =0
virtual void read(std::istream &)=0
virtual ~MapBase()=default
virtual Vec3d voxelSize(const Vec3d &) const =0
virtual bool isLinear() const =0
Return true if this map is linear.
virtual bool hasUniformScale() const =0
Return true if the spacing between the image of latice is uniform in all directions.
virtual MapBase::Ptr preScale(const Vec3d &) const =0
virtual Vec3d applyInverseJacobian(const Vec3d &in) const =0
Apply the InverseJacobian of this map to a vector. For a linear map this is equivalent to applying th...
virtual Vec3d applyIJT(const Vec3d &in) const =0
Apply the Inverse Jacobian Transpose of this map to a vector. For a linear map this is equivalent to ...
SharedPtr< const MapBase > ConstPtr
Definition Maps.h:138
virtual double determinant(const Vec3d &) const =0
MapBase()
Definition Maps.h:247
virtual Vec3d applyIJT(const Vec3d &in, const Vec3d &domainPos) const =0
MapBase(const MapBase &)=default
virtual MapBase::Ptr postTranslate(const Vec3d &) const =0
virtual Name type() const =0
Return the name of this map's concrete type (e.g., "AffineMap").
virtual Vec3d applyInverseJacobian(const Vec3d &in, const Vec3d &domainPos) const =0
virtual void write(std::ostream &) const =0
virtual Vec3d applyJacobian(const Vec3d &in) const =0
Apply the Jacobian of this map to a vector. For a linear map this is equivalent to applying the map e...
virtual MapBase::Ptr preTranslate(const Vec3d &) const =0
virtual MapBase::Ptr postRotate(double radians, Axis axis=X_AXIS) const =0
virtual MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const =0
virtual MapBase::Ptr postScale(const Vec3d &) const =0
virtual Vec3d applyJacobian(const Vec3d &in, const Vec3d &domainPos) const =0
virtual MapBase::Ptr inverseMap() const =0
Return a new map representing the inverse of this map.
Ptr(*)() MapFactory
Definition Maps.h:139
virtual bool isEqual(const MapBase &other) const =0
Return true if this map is equal to the given map.
virtual MapBase::Ptr preRotate(double radians, Axis axis=X_AXIS) const =0
Methods to update the map.
static MapBase::Ptr createMap(const Name &)
Create a new map of the given (registered) type name.
static void clear()
Clear the map type registry.
static void unregisterMap(const Name &)
Remove a map type from the registry.
static bool isRegistered(const Name &)
Return true if the given map type name is registered.
std::map< Name, MapBase::MapFactory > MapDictionary
Definition Maps.h:265
static MapRegistry * instance()
static void registerMap(const Name &, MapBase::MapFactory)
Register a map type along with a factory function.
void setToRotation(const Quat< T > &q)
Set this matrix to the rotation matrix specified by the quaternion.
Definition Mat3.h:253
Mat3 inverse(T tolerance=0) const
Definition Mat3.h:465
void setCol(int j, const Vec3< T > &v)
Set jth column to vector v.
Definition Mat3.h:159
Mat3 transpose() const
returns transpose of this
Definition Mat3.h:454
T det() const
Determinant of matrix.
Definition Mat3.h:479
static const Mat3< double > & zero()
Definition Mat3.h:131
Vec3< T > col(int j) const
Get jth column, e.g. Vec3d v = m.col(0);.
Definition Mat3.h:168
void setRow(int i, const Vec3< T > &v)
Set ith row to vector v.
Definition Mat3.h:141
Mat4 inverse(T tolerance=0) const
Definition Mat4.h:485
Mat3< T > getMat3() const
Definition Mat4.h:297
static const Mat4< double > & identity()
Definition Mat4.h:117
void setToRotation(Axis axis, T angle)
Sets the matrix to a rotation about the given axis.
Definition Mat4.h:783
Vec4< T0 > transform(const Vec4< T0 > &v) const
Transform a Vec4 by post-multiplication.
Definition Mat4.h:999
void setTranslation(const Vec3< T > &t)
Definition Mat4.h:314
void setMat3(const Mat3< T > &m)
Set upper left to a Mat3.
Definition Mat4.h:290
MapBase::Ptr postScale(const Vec3d &s) const override
Return a MapBase::Ptr to a new map that is the result of appending the given scale to the linear part...
Definition Maps.h:2471
NonlinearFrustumMap()
Definition Maps.h:1897
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...
Definition Maps.h:1920
void setTaper(double t)
set the taper value, the ratio of nearplane width / far plane width
Definition Maps.h:2352
static void registerMap()
Definition Maps.h:2033
const BBoxd & getBBox() const
Return the bounding box that defines the frustum in pre-image space.
Definition Maps.h:2363
void write(std::ostream &os) const override
write serialization
Definition Maps.h:2405
bool operator!=(const NonlinearFrustumMap &other) const
Definition Maps.h:2094
const AffineMap & secondMap() const
Return MapBase::Ptr& to the second map.
Definition Maps.h:2366
double getGamma() const
Definition Maps.h:2360
double getDepth() const
Return the unscaled frustm depth.
Definition Maps.h:2358
Vec3d applyIJT(const Vec3d &d1_is, const Vec3d &ijk) const override
Definition Maps.h:2203
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Return a MapBase::Ptr to a new map that is the result of appending the given shear to the linear part...
Definition Maps.h:2478
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 given shear to the linear par...
Definition Maps.h:2449
MapBase::Ptr postTranslate(const Vec3d &t) const override
Return a MapBase::Ptr to a new map that is the result of appending the given translation to the linea...
Definition Maps.h:2464
Vec3d applyIJT(const Vec3d &in) const override
Return the transpose of the inverse Jacobian of the linear second map applied to in.
Definition Maps.h:2193
bool operator==(const NonlinearFrustumMap &other) const
Definition Maps.h:2072
bool isValid() const
Definition Maps.h:2369
Name type() const override
Return NonlinearFrustumMap.
Definition Maps.h:2040
AffineMap::Ptr getAffineMap() const override
Definition Maps.h:2349
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.
Definition Maps.h:1958
bool hasUniformScale() const override
Return false (by convention false)
Definition Maps.h:2048
MapBase::Ptr postRotate(double radians, Axis axis=X_AXIS) const override
Return a MapBase::Ptr to a new map that is the result of appending the given rotation to the linear p...
Definition Maps.h:2457
Vec3d applyJT(const Vec3d &in) const override
Return the Jacobian Transpose of the second map applied to in.
Definition Maps.h:2188
double determinant() const override
Return the determinant of the Jacobian of linear second map.
Definition Maps.h:2314
MapBase::Ptr copy() const override
Return a MapBase::Ptr to a deep copy of this map.
Definition Maps.h:2021
Vec3d applyJacobian(const Vec3d &in) const override
Return the Jacobian of the linear second map applied to in.
Definition Maps.h:2108
std::string str() const override
string serialization, useful for debuging
Definition Maps.h:2416
SharedPtr< const NonlinearFrustumMap > ConstPtr
Definition Maps.h:1895
bool isLinear() const override
Return false (a NonlinearFrustumMap is never linear).
Definition Maps.h:2045
Vec3d applyJT(const Vec3d &in, const Vec3d &isloc) const override
Return the Jacobian Transpose of the map applied to vector in at indexloc.
Definition Maps.h:2166
Vec3d applyInverseJacobian(const Vec3d &in) const override
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation)
Definition Maps.h:2135
MapBase::Ptr preTranslate(const Vec3d &t) const override
Return a MapBase::Ptr to a new map that is the result of prepending the given translation to the line...
Definition Maps.h:2435
Vec3d voxelSize() const override
Return the size of a voxel at the center of the near plane.
Definition Maps.h:2326
MapBase::Ptr preScale(const Vec3d &s) const override
Return a MapBase::Ptr to a new map that is the result of prepending the given scale to the linear par...
Definition Maps.h:2442
static bool isRegistered()
Definition Maps.h:2031
double determinant(const Vec3d &loc) const override
Definition Maps.h:2318
NonlinearFrustumMap(const NonlinearFrustumMap &other)
Definition Maps.h:1932
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...
Definition Maps.h:1909
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 given rotation to the linear ...
Definition Maps.h:2428
Mat3d applyIJC(const Mat3d &d2_is, const Vec3d &d1_is, const Vec3d &ijk) const override
Definition Maps.h:2244
Vec3d applyInverseJacobian(const Vec3d &in, const Vec3d &isloc) const override
Return the Inverse Jacobian defined at isloc of the map applied to in.
Definition Maps.h:2139
Vec3d applyMap(const Vec3d &in) const override
Return the image of in under the map.
Definition Maps.h:2097
MapBase::Ptr inverseMap() const override
Not implemented, since there is currently no map type that can represent the inverse of a frustum.
Definition Maps.h:2026
bool isIdentity() const
Return true if the map is equivalent to an identity.
Definition Maps.h:2051
void read(std::istream &is) override
read serialization
Definition Maps.h:2375
double getTaper() const
Return the taper value.
Definition Maps.h:2354
Vec3d applyInverseMap(const Vec3d &in) const override
Return the pre-image of in under the map.
Definition Maps.h:2103
Vec3d voxelSize(const Vec3d &loc) const override
Returns the lengths of the images of the three segments from loc to loc + (1,0,0),...
Definition Maps.h:2340
SharedPtr< NonlinearFrustumMap > Ptr
Definition Maps.h:1894
static MapBase::Ptr create()
Return a MapBase::Ptr to a new NonlinearFrustumMap.
Definition Maps.h:2019
void setDepth(double d)
set the frustum depth: distance between near and far plane = frustm depth * frustm x-width
Definition Maps.h:2356
Mat3d applyIJC(const Mat3d &in) const override
Return the Jacobian Curvature for the linear second map.
Definition Maps.h:2239
static Name mapType()
Return NonlinearFrustumMap.
Definition Maps.h:2042
Vec3d applyJacobian(const Vec3d &in, const Vec3d &isloc) const override
Return the Jacobian defined at isloc applied to in.
Definition Maps.h:2110
bool hasSimpleAffine() const
Return true if the second map is a uniform scale, Rotation and translation.
Definition Maps.h:2372
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
Definition Maps.h:2070
~NonlinearFrustumMap() override=default
A specialized Affine transform that scales along the principal axis the scaling need not be uniform i...
Definition Maps.h:656
MapBase::Ptr postScale(const Vec3d &) const override
Definition Maps.h:970
Vec3d voxelSize() const final
Return the lengths of the images of the segments (0,0,0) − 1,0,0), (0,0,0) − (0,1,...
Definition Maps.h:808
const Vec3d & getScale() const
Return the scale values that define the map.
Definition Maps.h:795
Vec3d applyInverseMap(const Vec3d &in) const final
Return the pre-image of in under the map.
Definition Maps.h:734
static void registerMap()
Definition Maps.h:702
void write(std::ostream &os) const override
write serialization
Definition Maps.h:822
SharedPtr< const ScaleMap > ConstPtr
Definition Maps.h:659
Vec3d applyMap(const Vec3d &in) const final
Return the image of in under the map.
Definition Maps.h:726
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Definition Maps.h:890
MapBase::Ptr preShear(double shear, Axis axis0, Axis axis1) const override
Definition Maps.h:870
ScaleMap(const Vec3d &scale)
Definition Maps.h:665
double determinant(const Vec3d &) const final
Return the product of the scale values, ignores argument.
Definition Maps.h:788
MapBase::Ptr postTranslate(const Vec3d &) const override
Definition Maps.h:1458
Vec3d applyIJT(const Vec3d &in) const final
Return the transpose of the inverse Jacobian of the map applied to in.
Definition Maps.h:771
Vec3d applyIJT(const Vec3d &in, const Vec3d &) const final
Return the transpose of the inverse Jacobian of the map applied to in.
Definition Maps.h:767
const Vec3d & getInvScale() const
Return 1/(scale)
Definition Maps.h:802
Vec3d applyJacobian(const Vec3d &in, const Vec3d &) const final
Return the Jacobian of the map applied to in.
Definition Maps.h:742
bool isLinear() const final
Return true (a ScaleMap is always linear).
Definition Maps.h:713
Name type() const override
Return the name of this map's concrete type (e.g., "AffineMap").
Definition Maps.h:709
AffineMap::Ptr getAffineMap() const override
Return a AffineMap equivalent to this map.
Definition Maps.h:851
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 ...
Definition Maps.h:882
MapBase::Ptr copy() const override
Return a MapBase::Ptr to a deep copy of this map.
Definition Maps.h:694
std::string str() const override
string serialization, useful for debuging
Definition Maps.h:831
MapBase::Ptr preTranslate(const Vec3d &) const override
Definition Maps.h:1465
Vec3d applyInverseJacobian(const Vec3d &in, const Vec3d &) const final
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation)
Definition Maps.h:750
Vec3d applyJacobian(const Vec3d &in) const final
Return the Jacobian of the map applied to in.
Definition Maps.h:746
Mat3d applyIJC(const Mat3d &in) const final
Return the Jacobian Curvature: zero for a linear map.
Definition Maps.h:773
~ScaleMap() override=default
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 ...
Definition Maps.h:861
Vec3d applyJT(const Vec3d &in) const final
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:763
Vec3d voxelSize(const Vec3d &) const final
Definition Maps.h:809
bool operator==(const ScaleMap &other) const
Definition Maps.h:841
static bool isRegistered()
Definition Maps.h:700
ScaleMap()
Definition Maps.h:661
double determinant() const final
Return the product of the scale values.
Definition Maps.h:790
Vec3d applyJT(const Vec3d &in, const Vec3d &) const final
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:761
const Vec3d & getInvTwiceScale() const
Return 1/(2 scale). Used to optimize some finite difference calculations.
Definition Maps.h:800
ScaleMap(const ScaleMap &other)
Definition Maps.h:679
bool hasUniformScale() const final
Return true if the values have the same magitude (eg. -1, 1, -1 would be a rotation).
Definition Maps.h:716
Mat3d applyIJC(const Mat3d &in, const Vec3d &, const Vec3d &) const final
Definition Maps.h:784
MapBase::Ptr inverseMap() const override
Return a new map representing the inverse of this map.
Definition Maps.h:696
const Vec3d & getInvScaleSqr() const
Return the square of the scale. Used to optimize some finite difference calculations.
Definition Maps.h:798
void read(std::istream &is) override
read serialization
Definition Maps.h:813
bool operator!=(const ScaleMap &other) const
Definition Maps.h:848
MapBase::Ptr preScale(const Vec3d &) const override
Definition Maps.h:958
static MapBase::Ptr create()
Return a MapBase::Ptr to a new ScaleMap.
Definition Maps.h:692
static Name mapType()
Definition Maps.h:710
SharedPtr< ScaleMap > Ptr
Definition Maps.h:658
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
Definition Maps.h:839
Vec3d applyInverseJacobian(const Vec3d &in) const final
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation)
Definition Maps.h:755
A specialized Affine transform that scales along the principal axis the scaling need not be uniform i...
Definition Maps.h:1163
Vec3d voxelSize() const final
Return the absolute values of the scale values.
Definition Maps.h:1333
const Vec3d & getScale() const
Returns the scale values.
Definition Maps.h:1338
bool operator==(const ScaleTranslateMap &other) const
Definition Maps.h:1381
ScaleTranslateMap(const ScaleTranslateMap &other)
Definition Maps.h:1207
Vec3d applyInverseMap(const Vec3d &in) const final
Return the pre-image of under the map.
Definition Maps.h:1265
static void registerMap()
Definition Maps.h:1232
bool operator!=(const ScaleTranslateMap &other) const
Definition Maps.h:1389
void write(std::ostream &os) const override
write serialization
Definition Maps.h:1360
~ScaleTranslateMap() override=default
Vec3d applyMap(const Vec3d &in) const final
Return the image of under the map.
Definition Maps.h:1257
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Definition Maps.h:1443
MapBase::Ptr preShear(double shear, Axis axis0, Axis axis1) const override
Definition Maps.h:1419
double determinant(const Vec3d &) const final
Return the product of the scale values, ignores argument.
Definition Maps.h:1327
Vec3d applyIJT(const Vec3d &in) const final
Return the transpose of the inverse Jacobian of the map applied to in.
Definition Maps.h:1303
const Vec3d & getTranslation() const
Returns the translation.
Definition Maps.h:1340
MapBase::Ptr postTranslate(const Vec3d &t) const override
Definition Maps.h:1436
Vec3d applyIJT(const Vec3d &in, const Vec3d &) const final
Return the transpose of the inverse Jacobian of the map applied to in.
Definition Maps.h:1299
const Vec3d & getInvScale() const
Return 1/(scale)
Definition Maps.h:1347
Vec3d applyJacobian(const Vec3d &in, const Vec3d &) const final
Return the Jacobian of the map applied to in.
Definition Maps.h:1274
bool isLinear() const final
Return true (a ScaleTranslateMap is always linear).
Definition Maps.h:1243
MapBase::Ptr postScale(const Vec3d &v) const override
Definition Maps.h:1600
Name type() const override
Return the name of this map's concrete type (e.g., "AffineMap").
Definition Maps.h:1239
AffineMap::Ptr getAffineMap() const override
Return AffineMap::Ptr to an AffineMap equivalent to *this.
Definition Maps.h:1392
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.
Definition Maps.h:1430
SharedPtr< ScaleTranslateMap > Ptr
Definition Maps.h:1165
MapBase::Ptr copy() const override
Return a MapBase::Ptr to a deep copy of this map.
Definition Maps.h:1222
std::string str() const override
string serialization, useful for debuging
Definition Maps.h:1370
Vec3d applyInverseJacobian(const Vec3d &in, const Vec3d &) const final
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation)
Definition Maps.h:1282
Vec3d applyJacobian(const Vec3d &in) const final
Return the Jacobian of the map applied to in.
Definition Maps.h:1278
Mat3d applyIJC(const Mat3d &in) const final
Return the Jacobian Curvature: zero for a linear map.
Definition Maps.h:1311
ScaleTranslateMap(const Vec3d &scale, const Vec3d &translate)
Definition Maps.h:1179
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.
Definition Maps.h:1402
MapBase::Ptr preScale(const Vec3d &v) const override
Definition Maps.h:1588
Vec3d applyJT(const Vec3d &in) const final
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:1295
Vec3d voxelSize(const Vec3d &) const final
Return the absolute values of the scale values, ignores argument.
Definition Maps.h:1335
MapBase::Ptr preTranslate(const Vec3d &t) const override
Definition Maps.h:1408
SharedPtr< const ScaleTranslateMap > ConstPtr
Definition Maps.h:1166
static bool isRegistered()
Definition Maps.h:1230
double determinant() const final
Return the product of the scale values.
Definition Maps.h:1329
Vec3d applyJT(const Vec3d &in, const Vec3d &) const final
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:1293
ScaleTranslateMap(const ScaleMap &scale, const TranslationMap &translate)
Definition Maps.h:1194
const Vec3d & getInvTwiceScale() const
Return 1/(2 scale). Used to optimize some finite difference calculations.
Definition Maps.h:1345
bool hasUniformScale() const final
Return true if the scale values have the same magnitude (eg. -1, 1, -1 would be a rotation).
Definition Maps.h:1247
Mat3d applyIJC(const Mat3d &in, const Vec3d &, const Vec3d &) const final
Definition Maps.h:1322
ScaleTranslateMap()
Definition Maps.h:1168
MapBase::Ptr inverseMap() const override
Return a new map representing the inverse of this map.
Definition Maps.h:1224
const Vec3d & getInvScaleSqr() const
Return the square of the scale. Used to optimize some finite difference calculations.
Definition Maps.h:1343
void read(std::istream &is) override
read serialization
Definition Maps.h:1350
static MapBase::Ptr create()
Return a MapBase::Ptr to a new ScaleTranslateMap.
Definition Maps.h:1220
static Name mapType()
Definition Maps.h:1240
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
Definition Maps.h:1379
Vec3d applyInverseJacobian(const Vec3d &in) const final
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation)
Definition Maps.h:1287
A specialized linear transform that performs a translation.
Definition Maps.h:978
TranslationMap(const TranslationMap &other)
Definition Maps.h:986
static void registerMap()
Definition Maps.h:1001
void write(std::ostream &os) const override
write serialization
Definition Maps.h:1070
Vec3d voxelSize(const Vec3d &) const override
Return (1,1,1).
Definition Maps.h:1062
Vec3d applyJT(const Vec3d &in, const Vec3d &) const override
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:1038
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Definition Maps.h:1141
MapBase::Ptr preShear(double shear, Axis axis0, Axis axis1) const override
Definition Maps.h:1116
const Vec3d & getTranslation() const
Return the translation vector.
Definition Maps.h:1065
MapBase::Ptr postTranslate(const Vec3d &t) const override
Definition Maps.h:1134
Vec3d applyIJT(const Vec3d &in) const override
Return the transpose of the inverse Jacobian (Identity for TranslationMap) of the map applied to in.
Definition Maps.h:1047
~TranslationMap() override=default
SharedPtr< const TranslationMap > ConstPtr
Definition Maps.h:981
MapBase::Ptr postScale(const Vec3d &v) const override
Definition Maps.h:1574
Name type() const override
Return the name of this map's concrete type (e.g., "AffineMap").
Definition Maps.h:1008
AffineMap::Ptr getAffineMap() const override
Return AffineMap::Ptr to an AffineMap equivalent to *this.
Definition Maps.h:1090
double determinant(const Vec3d &) const override
Return 1.
Definition Maps.h:1055
bool hasUniformScale() const override
Return false (by convention true)
Definition Maps.h:1015
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.
Definition Maps.h:1127
TranslationMap()
Definition Maps.h:984
Mat3d applyIJC(const Mat3d &mat) const override
Return the Jacobian Curvature: zero for a linear map.
Definition Maps.h:1049
Vec3d applyJT(const Vec3d &in) const override
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:1040
double determinant() const override
Return 1.
Definition Maps.h:1057
Vec3d applyJacobian(const Vec3d &in, const Vec3d &) const override
Return the Jacobian of the map applied to in.
Definition Maps.h:1022
Mat3d applyIJC(const Mat3d &mat, const Vec3d &, const Vec3d &) const override
Definition Maps.h:1050
MapBase::Ptr copy() const override
Return a MapBase::Ptr to a deep copy of this map.
Definition Maps.h:993
Vec3d applyJacobian(const Vec3d &in) const override
Return the Jacobian of the map applied to in.
Definition Maps.h:1024
std::string str() const override
string serialization, useful for debuging
Definition Maps.h:1072
bool isLinear() const override
Return true (a TranslationMap is always linear).
Definition Maps.h:1012
TranslationMap(const Vec3d &t)
Definition Maps.h:985
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.
Definition Maps.h:1102
MapBase::Ptr preScale(const Vec3d &v) const override
Definition Maps.h:1563
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)
Definition Maps.h:1028
Vec3d applyInverseJacobian(const Vec3d &in) const override
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation)
Definition Maps.h:1033
bool operator==(const TranslationMap &other) const
Definition Maps.h:1081
MapBase::Ptr preTranslate(const Vec3d &t) const override
Definition Maps.h:1109
Vec3d voxelSize() const override
Return (1,1,1).
Definition Maps.h:1060
static bool isRegistered()
Definition Maps.h:999
SharedPtr< TranslationMap > Ptr
Definition Maps.h:980
Vec3d applyIJT(const Vec3d &in, const Vec3d &) const override
Return the transpose of the inverse Jacobian (Identity for TranslationMap) of the map applied to in,...
Definition Maps.h:1044
Vec3d applyMap(const Vec3d &in) const override
Return the image of in under the map.
Definition Maps.h:1018
MapBase::Ptr inverseMap() const override
Return a new map representing the inverse of this map.
Definition Maps.h:995
void read(std::istream &is) override
read serialization
Definition Maps.h:1068
Vec3d applyInverseMap(const Vec3d &in) const override
Return the pre-image of in under the map.
Definition Maps.h:1020
static MapBase::Ptr create()
Return a MapBase::Ptr to a new TranslationMap.
Definition Maps.h:991
static Name mapType()
Definition Maps.h:1009
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
Definition Maps.h:1079
bool operator!=(const TranslationMap &other) const
Definition Maps.h:1087
A specialized linear transform that performs a unitary maping i.e. rotation and or reflection.
Definition Maps.h:1621
static void registerMap()
Definition Maps.h:1707
bool operator==(const UnitaryMap &other) const
Definition Maps.h:1727
void write(std::ostream &os) const override
write serialization
Definition Maps.h:1795
Vec3d voxelSize(const Vec3d &) const override
Returns the lengths of the images of the segments (0,0,0) − (1,0,0), (0,0,0) − (0,...
Definition Maps.h:1785
Vec3d applyJT(const Vec3d &in, const Vec3d &) const override
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:1757
MapBase::Ptr postShear(double shear, Axis axis0, Axis axis1) const override
Return a MapBase::Ptr to a new map that is the result of appending the given shear.
Definition Maps.h:1870
UnitaryMap(const Mat4d &m)
Definition Maps.h:1657
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 given shear.
Definition Maps.h:1837
MapBase::Ptr postTranslate(const Vec3d &t) const override
Return a MapBase::Ptr to a new map that is the result of appending the given translation.
Definition Maps.h:1854
Vec3d applyIJT(const Vec3d &in) const override
Return the transpose of the inverse Jacobian of the map applied to in.
Definition Maps.h:1768
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.
Definition Maps.h:1862
Name type() const override
Return UnitaryMap.
Definition Maps.h:1715
AffineMap::Ptr getAffineMap() const override
Return AffineMap::Ptr to an AffineMap equivalent to *this.
Definition Maps.h:1807
double determinant(const Vec3d &) const override
Return the determinant of the Jacobian, ignores argument.
Definition Maps.h:1776
bool hasUniformScale() const override
Return false (by convention true)
Definition Maps.h:1723
MapBase::Ptr postRotate(double radians, Axis axis) const override
Return a MapBase::Ptr to a new map that is the result of appending the given rotation.
Definition Maps.h:1846
Vec3d applyJT(const Vec3d &in) const override
Return the Jacobian Transpose of the map applied to in.
Definition Maps.h:1759
double determinant() const override
Return the determinant of the Jacobian.
Definition Maps.h:1778
Vec3d applyJacobian(const Vec3d &in, const Vec3d &) const override
Definition Maps.h:1740
Mat3d applyIJC(const Mat3d &in, const Vec3d &, const Vec3d &) const override
Definition Maps.h:1771
MapBase::Ptr copy() const override
Returns a MapBase::Ptr to a deep copy of *this.
Definition Maps.h:1698
~UnitaryMap() override=default
Vec3d applyJacobian(const Vec3d &in) const override
Return the Jacobian of the map applied to in.
Definition Maps.h:1742
std::string str() const override
string serialization, useful for debuging
Definition Maps.h:1800
bool isLinear() const override
Return true (a UnitaryMap is always linear).
Definition Maps.h:1720
MapBase::Ptr preRotate(double radians, Axis axis) const override
Return a MapBase::Ptr to a new map that is the result of prepending the given rotation.
Definition Maps.h:1813
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.
Definition Maps.h:1829
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)
Definition Maps.h:1746
Vec3d applyInverseJacobian(const Vec3d &in) const override
Return the Inverse Jacobian of the map applied to in (i.e. inverse map with out translation)
Definition Maps.h:1751
UnitaryMap(const Vec3d &axis, double radians)
Definition Maps.h:1631
MapBase::Ptr preTranslate(const Vec3d &t) const override
Return a MapBase::Ptr to a new map that is the result of prepending the given translation.
Definition Maps.h:1821
Vec3d voxelSize() const override
Returns the lengths of the images of the segments (0,0,0) − (1,0,0), (0,0,0) − (0,...
Definition Maps.h:1784
static bool isRegistered()
Definition Maps.h:1705
UnitaryMap(Axis axis, double radians)
Definition Maps.h:1638
SharedPtr< const UnitaryMap > ConstPtr
Definition Maps.h:1624
UnitaryMap(const UnitaryMap &other)
Definition Maps.h:1682
Vec3d applyIJT(const Vec3d &in, const Vec3d &) const override
Return the transpose of the inverse Jacobian of the map applied to in.
Definition Maps.h:1766
Vec3d applyMap(const Vec3d &in) const override
Return the image of in under the map.
Definition Maps.h:1736
MapBase::Ptr inverseMap() const override
Return a new map representing the inverse of this map.
Definition Maps.h:1700
UnitaryMap()
default constructor makes an Idenity.
Definition Maps.h:1627
void read(std::istream &is) override
read serialization
Definition Maps.h:1789
Vec3d applyInverseMap(const Vec3d &in) const override
Return the pre-image of in under the map.
Definition Maps.h:1738
static MapBase::Ptr create()
Return a MapBase::Ptr to a new UnitaryMap.
Definition Maps.h:1696
bool operator!=(const UnitaryMap &other) const
Definition Maps.h:1734
Mat3d applyIJC(const Mat3d &in) const override
Return the Jacobian Curvature: zero for a linear map.
Definition Maps.h:1770
SharedPtr< UnitaryMap > Ptr
Definition Maps.h:1623
static Name mapType()
Return UnitaryMap.
Definition Maps.h:1717
UnitaryMap(const Mat3d &m)
Definition Maps.h:1645
UnitaryMap(const UnitaryMap &first, const UnitaryMap &second)
Definition Maps.h:1688
bool isEqual(const MapBase &other) const override
Return true if this map is equal to the given map.
Definition Maps.h:1725
T & x()
Reference to the component, e.g. v.x() = 4.5f;.
Definition Vec3.h:86
T length() const
Length of the vector.
Definition Vec3.h:201
T dot(const Vec3< T > &v) const
Dot product.
Definition Vec3.h:192
T * asPointer()
Definition Vec3.h:95
T & y()
Definition Vec3.h:87
T & z()
Definition Vec3.h:88
bool normalize(T eps=T(1.0e-7))
this = normalized this
Definition Vec3.h:363
OPENVDB_API uint32_t getFormatVersion(std::ios_base &)
Return the file format version number associated with the given input stream.
bool hasTranslation(const Mat4< T > &m)
Definition Mat4.h:1310
Mat3< double > Mat3d
Definition Mat3.h:834
SpectralDecomposedMap SymmetricMap
Definition Maps.h:46
OPENVDB_API SharedPtr< SymmetricMap > createSymmetricMap(const Mat3d &m)
Utility methods.
OPENVDB_API SharedPtr< PolarDecomposedMap > createPolarDecomposedMap(const Mat3d &m)
Decomposes a general linear into translation following polar decomposition.
bool isDiagonal(const MatType &mat)
Determine if a matrix is diagonal.
Definition Mat.h:902
OPENVDB_API SharedPtr< MapBase > simplify(SharedPtr< AffineMap > affine)
reduces an AffineMap to a ScaleMap or a ScaleTranslateMap when it can
bool isApproxEqual(const Type &a, const Type &b, const Type &tolerance)
Return true if a is equal to b to within the given tolerance.
Definition Math.h:406
CompoundMap< UnitaryMap, TranslationMap > UnitaryAndTranslationMap
Definition Maps.h:44
CompoundMap< SymmetricMap, UnitaryAndTranslationMap > FullyDecomposedMap
Definition Maps.h:47
bool isInvertible(const MatType &m)
Determine if a matrix is invertible.
Definition Mat.h:869
OPENVDB_API Mat4d approxInverse(const Mat4d &mat)
Returns the left pseudoInverse of the input matrix when the 3x3 part is symmetric otherwise it zeros ...
MatType scale(const Vec3< typename MatType::value_type > &s)
Return a matrix that scales by s.
Definition Mat.h:615
bool isUnitary(const MatType &m)
Determine if a matrix is unitary (i.e., rotation or reflection).
Definition Mat.h:889
CompoundMap< CompoundMap< UnitaryMap, ScaleMap >, UnitaryMap > SpectralDecomposedMap
Definition Maps.h:45
Vec3< double > Vec3d
Definition Vec3.h:665
OPENVDB_API SharedPtr< FullyDecomposedMap > createFullyDecomposedMap(const Mat4d &m)
General decomposition of a Matrix into a Unitary (e.g. rotation) following a Symmetric (e....
bool isAffine(const Mat4< T > &m)
Definition Mat4.h:1305
CompoundMap< SymmetricMap, UnitaryMap > PolarDecomposedMap
Definition Maps.h:48
Mat4< double > Mat4d
Definition Mat4.h:1355
float Round(float x)
Return x rounded to the nearest integer.
Definition Math.h:819
bool isIdentity(const MatType &m)
Determine if a matrix is an identity matrix.
Definition Mat.h:860
MatType shear(Axis axis0, Axis axis1, typename MatType::value_type shear)
Set the matrix to a shear along axis0 by a fraction of axis1.
Definition Mat.h:688
Axis
Definition Math.h:901
@ X_AXIS
Definition Math.h:902
std::string Name
Definition Name.h:19
Name readString(std::istream &is)
Definition Name.h:22
void writeString(std::ostream &os, const Name &name)
Definition Name.h:33
@ OPENVDB_FILE_VERSION_FLOAT_FRUSTUM_BBOX
Definition version.h.in:261
math::BBox< Vec3d > BBoxd
Definition Types.h:84
std::shared_ptr< T > SharedPtr
Definition Types.h:114
SharedPtr< T > StaticPtrCast(const SharedPtr< U > &ptr)
Return a new shared pointer that points to the same object as the given pointer after a static_cast.
Definition Types.h:146
Definition Exceptions.h:13
#define OPENVDB_THROW(exception, message)
Definition Exceptions.h:74
static T value()
Definition Math.h:148
static const bool value
Definition Maps.h:91
static const bool value
Definition Maps.h:56
static const bool value
Definition Maps.h:65
static const bool value
Definition Maps.h:57
static const bool value
Definition Maps.h:61
static const bool value
Definition Maps.h:60
static const bool value
Definition Maps.h:59
Map traits.
Definition Maps.h:55
static const bool value
Definition Maps.h:55
static const bool value
Definition Maps.h:80
static const bool value
Definition Maps.h:83
static const bool value
Definition Maps.h:82
static const bool value
Definition Maps.h:79
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition version.h.in:121
#define OPENVDB_USE_VERSION_NAMESPACE
Definition version.h.in:218