GT_VolumeUtil.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.
 *
 * NAME:        GT_VolumeUtil.h (GT Library, C++)
 *
 * COMMENTS:    Shared utilities between GT_PrimVDB and GT_PrimVolume
 */

#ifndef __GT_VOLUMEUTIL_H_INCLUDED__
#define __GT_VOLUMEUTIL_H_INCLUDED__

#include "GT_API.h"
#include "GT_DANumeric.h"
#include "GT_RefineParms.h"

#include <UT/UT_Assert.h>
#include <UT/UT_TaskGroup.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_VectorTypes.h>
#include <SYS/SYS_MathCbrt.h>
#include <SYS/SYS_Types.h>


/// Utility function for determining whether we should resample volumes in GT.
static inline bool
GTvolumeNeedResample(
        int xres, int yres, int zres,
        const GT_RefineParms *parms,
        fpreal &scale_factor)
{
    const fpreal max_lod = 4.0;
    const fpreal lod = SYSmin(GT_RefineParms::getLOD(parms), max_lod);

    const exint min_dim = 64;
    const fpreal min_voxels = min_dim * min_dim * min_dim * lod; 
    const fpreal num_voxels = exint(xres) * yres * zres;

    UT_ASSERT(num_voxels > 0);
    if (num_voxels > 0 && num_voxels < min_voxels)
    {
        scale_factor = SYScbrt(num_voxels / min_voxels);
        return true;
    }
    
    // No resampling needed
    scale_factor = 1.0;
    return false;
}

// Adapter for CopyTask
class GT_Vec3ArrayProxy
{
public:
    typedef UT_Vector3F value_type;

    GT_Vec3ArrayProxy(GT_Real32Array &arr) : myArray(&arr)
    {
    }

    UT_Vector3F &operator()(exint i)
    {
        return *reinterpret_cast<UT_Vector3F *>(myArray->getData(i));
    }

    void entries(exint num_items)
    {
        myArray->resize(num_items);
    }

private:
    GT_Real32Array *    myArray;
};

// Created by GTspawnCopyTask()
template <typename DstArrayT, typename SrcArrayT>
class GT_CopyTask
{
public:
    GT_CopyTask(DstArrayT &dst, exint dst_start,
             const SrcArrayT &src, exint num_elems)
        : myDst(&dst)
        , myDstStart(dst_start)
        , mySrc(&src)
        , myNumElems(num_elems)
    {
    }

    void operator()() const
    {
        exint bytes = myNumElems * sizeof(typename DstArrayT::value_type);
        ::memcpy(&(*myDst)(myDstStart), &(*mySrc)(0), bytes);
    }
    
private:
    DstArrayT *         myDst;
    exint               myDstStart;
    const SrcArrayT *   mySrc;
    exint               myNumElems;
};

/// Used to spawn array copy tasks, collecting them into given task group
template <typename DstArrayT, typename SrcArrayT>
static inline void
GTspawnCopyTask(
        UT_TaskGroup &tasks,
        DstArrayT &dst, exint dst_start,
        SrcArrayT &src, exint num_elems)
{
    if (num_elems <= 0)
        return;
    tasks.run(
            GT_CopyTask<DstArrayT, SrcArrayT>(dst, dst_start, src, num_elems));
}

/// Serial version of GTspawnCopyTask
template <typename DstArrayT, typename SrcArrayT>
static inline void
GTrunCopyTask(DstArrayT &dst, exint dst_start, SrcArrayT &src, exint num_elems)
{
    exint bytes = num_elems * sizeof(typename DstArrayT::value_type);
    ::memcpy(&dst(dst_start), &src(0), bytes);
}

/// Copy all the data in the thread chunks into a the destination.
template <typename DstArrayT, typename ThreadChunksT>
static inline void
GTmergeThreadChunks(DstArrayT &dst, const ThreadChunksT &chunks)
{
    using ChunkPtrT = typename ThreadChunksT::value_type;
    using ChunksIterT = typename ThreadChunksT::const_iterator;

    // Prepass to determine final destination size
    exint size = 0;
    exint max_items = 0;
    ChunksIterT end = chunks.end();
    for (ChunksIterT it = chunks.begin(); it != end; ++it)
    {
        const ChunkPtrT &chunk = it.get();
        if (!chunk)
            continue;

        exint src_items = chunk->size();
        if (src_items > max_items)
            max_items = src_items;
        size += src_items;
    }
    dst.entries(size);

    // Copy in parallel or serial
    if (max_items > 20000)
    {
        UT_TaskGroup copy_tasks;
        size = 0;
        for (ChunksIterT it = chunks.begin(); it != end; ++it)
        {
            const ChunkPtrT &chunk = it.get();
            if (!chunk)
                continue;
            chunk->spawnCopyTask(copy_tasks, dst, /*dst_start*/size);
            size += chunk->size();
        }
        copy_tasks.wait();
    }
    else
    {
        size = 0;
        for (ChunksIterT it = chunks.begin(); it != end; ++it)
        {
            const ChunkPtrT &chunk = it.get();
            if (!chunk)
                continue;
            chunk->runCopyTask(dst, /*dst_start*/size);
            size += chunk->size();
        }
    }
}

#endif // __GT_VOLUMEUTIL_H_INCLUDED__