SIM/SIM_FieldUtils.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        SIM_FieldUtils.h ( SIM Library, C++)
 *
 * COMMENTS:
 *      Templated functions for common behaviours
 *      in SIM_Fields.
 */

#ifndef __SIM_FieldUtils__
#define __SIM_FieldUtils__

#include <GU/GU_Types.h>

///
/// Returns true if there is a slice to be performed.
/// The slice is the half inclusive interval [minvxl, maxvxl)
/// 
template <typename FIELDTYPE>
bool
SIMfieldUtilsComputeSliceWithBorder(const FIELDTYPE *field, const UT_Vector3 &totaldiv, UT_Vector3 overlapneg, UT_Vector3 overlappos, int slicenum, UT_Vector3 &minvxl, UT_Vector3 &maxvxl)
{
    UT_Vector3          slice = field->getSliceDivisions();

    if (slice.isEqual(UT_Vector3(1, 1, 1)))
    {
        minvxl = UT_Vector3(0, 0, 0);
        maxvxl = totaldiv;
        // Trivially unsliced
        return false;
    }

    int                 sx, sy, sz;
    int                 x, y, z;

    sx = SYSrint(slice(0));
    sy = SYSrint(slice(1));
    sz = SYSrint(slice(2));

    if (slicenum < 0 || slicenum >= sx*sy*sz)
    {
        // Unclear if this should be impossible via UI, and if so,
        // how to make it so.
        slicenum = 0;
    }
    x = slicenum % sx;
    slicenum -= x;
    slicenum /= sx;
    y = slicenum % sy;
    slicenum -= y;
    slicenum /= sy;
    z = slicenum;

    minvxl.x() = SYSrint( x * (totaldiv.x() / sx) );
    maxvxl.x() = SYSrint( (x+1) * (totaldiv.x() / sx) );
    minvxl.y() = SYSrint( y * (totaldiv.y() / sy) );
    maxvxl.y() = SYSrint( (y+1) * (totaldiv.y() / sy) );
    minvxl.z() = SYSrint( z * (totaldiv.z() / sz) );
    maxvxl.z() = SYSrint( (z+1) * (totaldiv.z() / sz) );

    // Adjust for our borders.
    minvxl -= overlapneg;
    maxvxl += overlappos;
    
    minvxl.x() = SYSclamp(minvxl.x(), 0.0, totaldiv.x());
    maxvxl.x() = SYSclamp(maxvxl.x(), 0.0, totaldiv.x());
    minvxl.y() = SYSclamp(minvxl.y(), 0.0, totaldiv.y());
    maxvxl.y() = SYSclamp(maxvxl.y(), 0.0, totaldiv.y());
    minvxl.z() = SYSclamp(minvxl.z(), 0.0, totaldiv.z());
    maxvxl.z() = SYSclamp(maxvxl.z(), 0.0, totaldiv.z());

    // Special case: we need at least one voxel in each direction.
    if (maxvxl.x() - minvxl.x() < 1)
        maxvxl.x()++;
    if (maxvxl.y() - minvxl.y() < 1)
        maxvxl.y()++;
    if (maxvxl.z() - minvxl.z() < 1)
        maxvxl.z()++;

    // Clamp again...
    maxvxl.x() = SYSclamp(maxvxl.x(), 0.0, totaldiv.x());
    maxvxl.y() = SYSclamp(maxvxl.y(), 0.0, totaldiv.y());
    maxvxl.z() = SYSclamp(maxvxl.z(), 0.0, totaldiv.z());

    // Verify we are still valid.
    if (maxvxl.x() - minvxl.x() < 1)
        minvxl.x()--;
    if (maxvxl.y() - minvxl.y() < 1)
        minvxl.y()--;
    if (maxvxl.z() - minvxl.z() < 1)
        minvxl.z()--;

    return true;
}

template <typename FIELDTYPE>
bool
SIMfieldUtilsComputeSlice(const FIELDTYPE *field, const UT_Vector3 &totaldiv, int slicenum, UT_Vector3 &minvxl, UT_Vector3 &maxvxl)
{
    return SIMfieldUtilsComputeSliceWithBorder(
            field, totaldiv,
            field->getSliceOverlapNeg(), field->getSliceOverlapPos(),
            slicenum, minvxl, maxvxl);
}

/// Returns true if there is any overlap between the two
/// slices.  [minvxl, maxvxl)  is the region of overlap.
/// This is the intersection of the two slice fields.
template <typename FIELDTYPE>
bool
SIMfieldUtilsGetSliceBorder(const FIELDTYPE *field,
                        int a_slice, int b_slice,
                        UT_Vector3 &minvxl, UT_Vector3 &maxvxl)
{
    UT_Vector3          a_min, a_max, b_min, b_max;
    UT_Vector3          div;

    div = SIMfieldUtilsGetDivisionsNoSlice(field);

    SIMfieldUtilsComputeSlice(field, div, a_slice, a_min, a_max);
    SIMfieldUtilsComputeSlice(field, div, b_slice, b_min, b_max);
    
    UT_BoundingBox      a_box(a_min, a_max), b_box(b_min, b_max);

    if (!a_box.computeIntersection(b_box))
        return false;

    minvxl = a_box.minvec();
    maxvxl = a_box.maxvec();

    return true;
}

template <typename FIELDTYPE>
UT_Vector3
SIMfieldUtilsGetDivisionsNoSlice(const FIELDTYPE *field)
{
    UT_Vector3          div;
    int                 uniform;

    uniform = field->getUniformVoxels();
    if (uniform)
    {
        UT_Vector3              size, searchsize;
        int                     axis, a;
        fpreal                  voxelsize;
        fpreal                  uniformdiv;

        size = field->getRawSize();
        uniformdiv = field->getRawUniformDivisions();

        searchsize = size;

        // Force voxels to be uniform, by hook or by crook.
        // This axis will be taken as authoritative.
        axis = uniform-1;

        if (field->getTwoDField())
        {
            // We cannot use an axis that isn't represented.
            // For maximum axis case, we clamp the non represented
            // axis to 0 size to make sure we ignore it.
            switch (field->getVoxelPlane())
            {
                case GU_PLANE_XY:
                    if (axis == 2)
                        axis = 0;
                    searchsize(2) = 0.0;
                    break;
                case GU_PLANE_YZ:
                    if (axis == 0)
                        axis = 1;
                    searchsize(0) = 0.0;
                    break;
                case GU_PLANE_XZ:
                    if (axis == 1)
                        axis = 2;
                    searchsize(1) = 0.0;
                    break;
            }
        }

        // Check to see if they requested a maximum voxel option.
        if (axis == 3)
        {
            axis = searchsize.findMaxAbsAxis();
        }

        voxelsize = size(axis) / uniformdiv;

        // It is possible for the user to accidentally specify a 
        // zero size through use of a ladder handle, which, obviously,
        // leads to bad things.
        if (UTequalZero(voxelsize))
        {
            // This, presumeably, also means that all axes are
            // the same as we found no maximum!
            div = uniformdiv;
        }
        else
        {
            // Determine the dimensions of the divisions.
            for (a = 0; a < 3; a++)
            {
                div(a) = SYSrint(size(a)/voxelsize);
                if (div(a) < 1.0)
                    div(a) = 1.0;
            }
            // div(axis) should evaluate to uniformdiv.
            // The exception will be if we are currently building
            // our divisions and thus have uniformdiv == 0.
            UT_ASSERT(!uniformdiv || UTisEqual(div(axis), uniformdiv));
        }
    }
    else
    {
        div = field->getRawDivisions();
    }

    if (field->getTwoDField())
    {
        // Clamp to twod.
        switch (field->getVoxelPlane())
        {
            case GU_PLANE_XY:
                div.z() = 1.0;
                break;
            case GU_PLANE_YZ:
                div.x() = 1.0;
                break;
            case GU_PLANE_XZ:
                div.y() = 1.0;
                break;
        }
    }

    return div;
}

template <typename FIELDTYPE>
UT_Vector3
SIMfieldUtilsGetDivisions(const FIELDTYPE *field)
{
    UT_Vector3          minvxl, maxvxl;
    UT_Vector3          div;

    div = SIMfieldUtilsGetDivisionsNoSlice(field);

    // Now compute divisions for our particular slice.
    SIMfieldUtilsComputeSlice(field, div, field->getSlice(), minvxl, maxvxl);

    maxvxl -= minvxl;

    return maxvxl;
}

template <typename FIELDTYPE>
UT_Vector3
SIMfieldUtilsGetSizeNoSlice(const FIELDTYPE *field)
{
    UT_Vector3          size;
    int                 uniform;

    size = field->getRawSize();

    uniform = field->getUniformVoxels();

    if (uniform)
    {
        int             axis;
        fpreal          voxelsize;
        UT_Vector3      div;
        UT_Vector3      searchsize;

        searchsize = size;
        axis = uniform-1;

        if (field->getTwoDField())
        {
            // We cannot use an axis that isn't represented.
            switch (field->getVoxelPlane())
            {
                case GU_PLANE_XY:
                    if (axis == 2)
                        axis = 0;
                    searchsize(2) = 0;
                    break;
                case GU_PLANE_YZ:
                    if (axis == 0)
                        axis = 1;
                    searchsize(0) = 0;
                    break;
                case GU_PLANE_XZ:
                    if (axis == 1)
                        axis = 2;
                    searchsize(1) = 0;
                    break;
            }
        }

        // Check to see if they requested a maximum voxel option.
        if (axis == 3)
            axis = searchsize.findMaxAbsAxis();

        // Taking into account 2d and uniformality:
        div = SIMfieldUtilsGetDivisionsNoSlice(field);

        // Recompute voxelsize...
        voxelsize = size(axis) / div(axis);

        // Now the other dimensions are a direct copy
        size = voxelsize * div;
    }

    return size;
}

template <typename FIELDTYPE>
UT_Vector3
SIMfieldUtilsGetSize(const FIELDTYPE *field)
{
    UT_Vector3          size;
    UT_Vector3          div;
    UT_Vector3          minvxl, maxvxl;

    div = SIMfieldUtilsGetDivisionsNoSlice(field);
    size = SIMfieldUtilsGetSizeNoSlice(field);

    if (SIMfieldUtilsComputeSlice(field, div, field->getSlice(), minvxl, maxvxl))
    {
        UT_Vector3              voxelsize;

        voxelsize = size / div;

        // Get actual sliced size.
        maxvxl -= minvxl;

        // Recompute oursize from there.
        size = maxvxl * voxelsize;
    }

    return size;
}

template <typename FIELDTYPE>
UT_Vector3
SIMfieldUtilsGetCenter(const FIELDTYPE *field)
{
    UT_Vector3          size;
    UT_Vector3          div;
    UT_Vector3          minvxl, maxvxl;
    UT_Vector3          center;

    div = SIMfieldUtilsGetDivisionsNoSlice(field);
    center = field->getRawCenter();

    if (SIMfieldUtilsComputeSlice(field, div, field->getSlice(), minvxl, maxvxl))
    {
        UT_Vector3              voxelsize;

        size = SIMfieldUtilsGetSizeNoSlice(field);

        voxelsize = size / div;
        // My actual center is found by averaging min/maxvxl and
        // casting back into our large voxel space.
        minvxl += maxvxl;
        minvxl *= 0.5;

        // Make our coordinates relative to the center of the box
        minvxl -= div / 2;

        // Convert to space
        minvxl *= voxelsize;

        center += minvxl;
    }

    return center;
}


template <typename FIELDTYPE, typename F2>
void
SIMfieldUtilsMatch(FIELDTYPE *field, const F2 *srcfield)
{
    field->setUniformVoxels(srcfield->getUniformVoxels());
    field->setTwoDField(srcfield->getTwoDField());
    field->setVoxelPlane(srcfield->getVoxelPlane());

    field->setRawDivisions(srcfield->getRawDivisions());
    field->setRawUniformDivisions(srcfield->getRawUniformDivisions());
    field->setRawSize(srcfield->getRawSize());
    field->setRawCenter(srcfield->getRawCenter());

    field->setSlice(srcfield->getSlice());
    field->setSliceDivisions(srcfield->getSliceDivisions());
    field->setSliceOverlapNeg(srcfield->getSliceOverlapNeg());
    field->setSliceOverlapPos(srcfield->getSliceOverlapPos());
}

#endif

---