1103 lines
42 KiB
C++
1103 lines
42 KiB
C++
//============================================================================
|
|
// Copyright (c) Kitware, Inc.
|
|
// All rights reserved.
|
|
// See LICENSE.txt for details.
|
|
// This software is distributed WITHOUT ANY WARRANTY; without even
|
|
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
// PURPOSE. See the above copyright notice for more information.
|
|
//
|
|
// Copyright 2014 Sandia Corporation.
|
|
// Copyright 2014 UT-Battelle, LLC.
|
|
// Copyright 2014 Los Alamos National Security.
|
|
//
|
|
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
|
|
// the U.S. Government retains certain rights in this software.
|
|
//
|
|
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
|
|
// Laboratory (LANL), the U.S. Government retains certain rights in
|
|
// this software.
|
|
//============================================================================
|
|
|
|
|
|
#ifndef vtk_m_worklet_wavelets_waveletdwt_h
|
|
#define vtk_m_worklet_wavelets_waveletdwt_h
|
|
|
|
#include <vtkm/worklet/wavelets/WaveletBase.h>
|
|
|
|
#include <vtkm/worklet/wavelets/WaveletTransforms.h>
|
|
|
|
#include <vtkm/cont/ArrayHandleConcatenate.h>
|
|
#include <vtkm/cont/ArrayHandleCounting.h>
|
|
#include <vtkm/cont/ArrayHandlePermutation.h>
|
|
|
|
#include <vtkm/Math.h>
|
|
#include <vtkm/cont/Timer.h>
|
|
|
|
namespace vtkm {
|
|
namespace worklet {
|
|
namespace wavelets {
|
|
|
|
class WaveletDWT : public WaveletBase
|
|
{
|
|
public:
|
|
|
|
// Constructor
|
|
WaveletDWT( WaveletName name ) : WaveletBase( name ) {}
|
|
|
|
typedef vtkm::Float64 FLOAT_64;
|
|
|
|
|
|
|
|
template< typename SigInArrayType, typename ExtensionArrayType, typename DeviceTag >
|
|
vtkm::Id Extend2D (const SigInArrayType &sigIn, // Input
|
|
vtkm::Id sigDimX,
|
|
vtkm::Id sigDimY,
|
|
vtkm::Id sigStartX,
|
|
vtkm::Id sigStartY,
|
|
vtkm::Id sigPretendDimX,
|
|
vtkm::Id sigPretendDimY,
|
|
ExtensionArrayType &ext1, // left/top extension
|
|
ExtensionArrayType &ext2, // right/bottom extension
|
|
vtkm::Id addLen,
|
|
vtkm::worklet::wavelets::DWTMode ext1Method,
|
|
vtkm::worklet::wavelets::DWTMode ext2Method,
|
|
bool pretendSigPaddedZero,
|
|
bool padZeroAtExt2,
|
|
bool modeLR, // true = left-right
|
|
// false = top-down
|
|
DeviceTag )
|
|
{
|
|
// pretendSigPaddedZero and padZeroAtExt2 cannot happen at the same time
|
|
VTKM_ASSERT( !pretendSigPaddedZero || !padZeroAtExt2 );
|
|
|
|
if( addLen == 0 ) // Haar kernel
|
|
{
|
|
ext1.PrepareForOutput( 0, DeviceTag() );
|
|
if( pretendSigPaddedZero || padZeroAtExt2 )
|
|
{
|
|
if( modeLR ) // right extension
|
|
{
|
|
ext2.PrepareForOutput( sigPretendDimY, DeviceTag() );
|
|
WaveletBase::DeviceAssignZero2DColumn( ext2, 1, sigPretendDimY, 0, DeviceTag() );
|
|
}
|
|
else // bottom extension
|
|
{
|
|
ext2.PrepareForOutput( sigPretendDimX, DeviceTag() );
|
|
WaveletBase::DeviceAssignZero2DRow( ext2, sigPretendDimX, 1, 0, DeviceTag() );
|
|
}
|
|
}
|
|
else
|
|
ext2.PrepareForOutput( 0, DeviceTag() );
|
|
return 0;
|
|
}
|
|
|
|
typedef typename SigInArrayType::ValueType ValueType;
|
|
typedef vtkm::cont::ArrayHandle< ValueType > ExtendArrayType;
|
|
typedef vtkm::worklet::wavelets::ExtensionWorklet2D ExtensionWorklet;
|
|
typedef typename vtkm::worklet::DispatcherMapField< ExtensionWorklet, DeviceTag >
|
|
DispatcherType;
|
|
vtkm::Id extDimX, extDimY;
|
|
vtkm::worklet::wavelets::ExtensionDirection2D dir;
|
|
|
|
// Work on left/top extension
|
|
{
|
|
if( modeLR )
|
|
{
|
|
dir = LEFT;
|
|
extDimX = addLen;
|
|
extDimY = sigPretendDimY;
|
|
}
|
|
else
|
|
{
|
|
dir = TOP;
|
|
extDimX = sigPretendDimX;
|
|
extDimY = addLen;
|
|
}
|
|
ext1.PrepareForOutput( extDimX * extDimY, DeviceTag() );
|
|
ExtensionWorklet worklet( extDimX, extDimY, sigDimX, sigDimY,
|
|
sigStartX, sigStartY, sigPretendDimX, sigPretendDimY, // use this area
|
|
ext1Method, dir, false ); // not treating sigIn as having zeros
|
|
DispatcherType dispatcher( worklet );
|
|
dispatcher.Invoke( ext1, sigIn );
|
|
}
|
|
|
|
// Work on right/bottom extension
|
|
if( !pretendSigPaddedZero && !padZeroAtExt2 )
|
|
{
|
|
if( modeLR )
|
|
{
|
|
dir = RIGHT;
|
|
extDimX = addLen;
|
|
extDimY = sigPretendDimY;
|
|
}
|
|
else
|
|
{
|
|
dir = BOTTOM;
|
|
extDimX = sigPretendDimX;
|
|
extDimY = addLen;
|
|
}
|
|
ext2.PrepareForOutput( extDimX * extDimY, DeviceTag() );
|
|
ExtensionWorklet worklet( extDimX, extDimY, sigDimX, sigDimY,
|
|
sigStartX, sigStartY, sigPretendDimX, sigPretendDimY, // use this area
|
|
ext2Method, dir, false );
|
|
DispatcherType dispatcher( worklet );
|
|
dispatcher.Invoke( ext2, sigIn );
|
|
}
|
|
else if( !pretendSigPaddedZero && padZeroAtExt2 )
|
|
{
|
|
if( modeLR )
|
|
{
|
|
dir = RIGHT;
|
|
extDimX = addLen+1;
|
|
extDimY = sigPretendDimY;
|
|
}
|
|
else
|
|
{
|
|
dir = BOTTOM;
|
|
extDimX = sigPretendDimX;
|
|
extDimY = addLen+1;
|
|
}
|
|
ext2.PrepareForOutput( extDimX * extDimY, DeviceTag() );
|
|
ExtensionWorklet worklet( extDimX, extDimY, sigDimX, sigDimY,
|
|
sigStartX, sigStartY, sigPretendDimX, sigPretendDimY,
|
|
ext2Method, dir, false );
|
|
DispatcherType dispatcher( worklet );
|
|
dispatcher.Invoke( ext2, sigIn );
|
|
/* Pad a zero at the end of cDTemp, when cDTemp is forced to have the same
|
|
length as cATemp. For example, with odd length signal, cA is 1 element
|
|
longer than cD.
|
|
*/
|
|
/* Update 10/24/2016: the extra element of cD shouldn't be zero, just be
|
|
* whatever it extends to be.
|
|
* if( modeLR )
|
|
* WaveletBase::DeviceAssignZero2DColumn( ext2, extDimX, extDimY,
|
|
* extDimX-1, DeviceTag() );
|
|
* else
|
|
* WaveletBase::DeviceAssignZero2DRow( ext2, extDimX, extDimY,
|
|
* extDimY-1, DeviceTag() );
|
|
*/
|
|
}
|
|
else // pretendSigPaddedZero
|
|
{
|
|
ExtendArrayType ext2Temp;
|
|
if( modeLR )
|
|
{
|
|
dir = RIGHT;
|
|
extDimX = addLen;
|
|
extDimY = sigPretendDimY;
|
|
}
|
|
else
|
|
{
|
|
dir = BOTTOM;
|
|
extDimX = sigPretendDimX;
|
|
extDimY = addLen;
|
|
}
|
|
ext2Temp.PrepareForOutput( extDimX * extDimY, DeviceTag() );
|
|
ExtensionWorklet worklet( extDimX, extDimY, sigDimX, sigDimY,
|
|
sigStartX, sigStartY, sigPretendDimX, sigPretendDimY,
|
|
ext2Method, dir, true ); // pretend sig is padded a zero
|
|
DispatcherType dispatcher( worklet );
|
|
dispatcher.Invoke( ext2Temp, sigIn );
|
|
|
|
if( modeLR )
|
|
{
|
|
ext2.PrepareForOutput( (extDimX+1) * extDimY, DeviceTag() );
|
|
WaveletBase::DeviceRectangleCopyTo( ext2Temp, extDimX, extDimY,
|
|
ext2, extDimX+1, extDimY,
|
|
1, 0, DeviceTag() );
|
|
WaveletBase::DeviceAssignZero2DColumn( ext2, extDimX+1, extDimY,
|
|
0, DeviceTag() );
|
|
}
|
|
else
|
|
{
|
|
ext2.PrepareForOutput( extDimX * (extDimY+1), DeviceTag() );
|
|
WaveletBase::DeviceRectangleCopyTo( ext2Temp, extDimX, extDimY,
|
|
ext2, extDimX, extDimY+1,
|
|
0, 1, DeviceTag() );
|
|
WaveletBase::DeviceAssignZero2DRow( ext2, extDimX, extDimY+1,
|
|
0, DeviceTag() );
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// Extend 1D signal
|
|
template< typename SigInArrayType, typename SigExtendedArrayType, typename DeviceTag >
|
|
vtkm::Id Extend1D( const SigInArrayType &sigIn, // Input
|
|
SigExtendedArrayType &sigOut, // Output
|
|
vtkm::Id addLen,
|
|
vtkm::worklet::wavelets::DWTMode leftExtMethod,
|
|
vtkm::worklet::wavelets::DWTMode rightExtMethod,
|
|
bool attachZeroRightLeft,
|
|
bool attachZeroRightRight,
|
|
DeviceTag )
|
|
{
|
|
// "right extension" can be attached a zero on either end, but not both ends.
|
|
VTKM_ASSERT( !attachZeroRightRight || !attachZeroRightLeft );
|
|
|
|
typedef typename SigInArrayType::ValueType ValueType;
|
|
typedef vtkm::cont::ArrayHandle< ValueType > ExtensionArrayType;
|
|
typedef vtkm::cont::ArrayHandleConcatenate< ExtensionArrayType, SigInArrayType>
|
|
ArrayConcat;
|
|
|
|
ExtensionArrayType leftExtend, rightExtend;
|
|
|
|
if( addLen == 0 ) // Haar kernel
|
|
{
|
|
if( attachZeroRightLeft || attachZeroRightRight )
|
|
{
|
|
leftExtend.PrepareForOutput( 0, DeviceTag() );
|
|
rightExtend.PrepareForOutput(1, DeviceTag() );
|
|
WaveletBase::DeviceAssignZero( rightExtend, 0, DeviceTag() );
|
|
}
|
|
else
|
|
{
|
|
leftExtend.PrepareForOutput( 0, DeviceTag() );
|
|
rightExtend.PrepareForOutput(0, DeviceTag() );
|
|
}
|
|
ArrayConcat leftOn( leftExtend, sigIn );
|
|
sigOut = vtkm::cont::make_ArrayHandleConcatenate( leftOn, rightExtend );
|
|
return 0;
|
|
}
|
|
|
|
leftExtend.PrepareForOutput( addLen, DeviceTag() );
|
|
vtkm::Id sigInLen = sigIn.GetNumberOfValues();
|
|
|
|
typedef vtkm::worklet::wavelets::LeftSYMHExtentionWorklet LeftSYMH;
|
|
typedef vtkm::worklet::wavelets::LeftSYMWExtentionWorklet LeftSYMW;
|
|
typedef vtkm::worklet::wavelets::RightSYMHExtentionWorklet RightSYMH;
|
|
typedef vtkm::worklet::wavelets::RightSYMWExtentionWorklet RightSYMW;
|
|
typedef vtkm::worklet::wavelets::LeftASYMHExtentionWorklet LeftASYMH;
|
|
typedef vtkm::worklet::wavelets::LeftASYMWExtentionWorklet LeftASYMW;
|
|
typedef vtkm::worklet::wavelets::RightASYMHExtentionWorklet RightASYMH;
|
|
typedef vtkm::worklet::wavelets::RightASYMWExtentionWorklet RightASYMW;
|
|
|
|
switch( leftExtMethod )
|
|
{
|
|
case SYMH:
|
|
{
|
|
LeftSYMH worklet( addLen );
|
|
vtkm::worklet::DispatcherMapField< LeftSYMH, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( leftExtend, sigIn );
|
|
break;
|
|
}
|
|
case SYMW:
|
|
{
|
|
LeftSYMW worklet( addLen );
|
|
vtkm::worklet::DispatcherMapField< LeftSYMW, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( leftExtend, sigIn );
|
|
break;
|
|
}
|
|
case ASYMH:
|
|
{
|
|
LeftASYMH worklet( addLen );
|
|
vtkm::worklet::DispatcherMapField< LeftASYMH, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( leftExtend, sigIn );
|
|
break;
|
|
}
|
|
case ASYMW:
|
|
{
|
|
LeftASYMW worklet( addLen );
|
|
vtkm::worklet::DispatcherMapField< LeftASYMW, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( leftExtend, sigIn );
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
vtkm::cont::ErrorControlInternal("Left extension mode not supported!");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
if( !attachZeroRightLeft ) // no attach zero, or only attach on RightRight
|
|
{
|
|
// Allocate memory
|
|
if( attachZeroRightRight )
|
|
rightExtend.PrepareForOutput( addLen+1, DeviceTag() );
|
|
else
|
|
rightExtend.PrepareForOutput( addLen, DeviceTag() );
|
|
|
|
switch( rightExtMethod )
|
|
{
|
|
case SYMH:
|
|
{
|
|
RightSYMH worklet( sigInLen );
|
|
vtkm::worklet::DispatcherMapField< RightSYMH, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( rightExtend, sigIn );
|
|
break;
|
|
}
|
|
case SYMW:
|
|
{
|
|
RightSYMW worklet( sigInLen );
|
|
vtkm::worklet::DispatcherMapField< RightSYMW, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( rightExtend, sigIn );
|
|
break;
|
|
}
|
|
case ASYMH:
|
|
{
|
|
RightASYMH worklet( sigInLen );
|
|
vtkm::worklet::DispatcherMapField< RightASYMH, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( rightExtend, sigIn );
|
|
break;
|
|
}
|
|
case ASYMW:
|
|
{
|
|
RightASYMW worklet( sigInLen );
|
|
vtkm::worklet::DispatcherMapField< RightASYMW, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( rightExtend, sigIn );
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
vtkm::cont::ErrorControlInternal("Right extension mode not supported!");
|
|
return 1;
|
|
}
|
|
}
|
|
if( attachZeroRightRight )
|
|
WaveletBase::DeviceAssignZero( rightExtend, addLen, DeviceTag() );
|
|
}
|
|
else // attachZeroRightLeft mode
|
|
{
|
|
typedef vtkm::cont::ArrayHandleConcatenate<SigInArrayType, ExtensionArrayType>
|
|
ConcatArray;
|
|
// attach a zero at the end of sigIn
|
|
ExtensionArrayType singleValArray;
|
|
singleValArray.PrepareForOutput(1, DeviceTag() );
|
|
WaveletBase::DeviceAssignZero( singleValArray, 0, DeviceTag() );
|
|
ConcatArray sigInPlusOne( sigIn, singleValArray );
|
|
|
|
// allocate memory for extension
|
|
rightExtend.PrepareForOutput( addLen, DeviceTag() );
|
|
|
|
switch( rightExtMethod )
|
|
{
|
|
case SYMH:
|
|
{
|
|
RightSYMH worklet( sigInLen + 1 );
|
|
vtkm::worklet::DispatcherMapField< RightSYMH, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( rightExtend, sigInPlusOne );
|
|
break;
|
|
}
|
|
case SYMW:
|
|
{
|
|
RightSYMW worklet( sigInLen + 1 );
|
|
vtkm::worklet::DispatcherMapField< RightSYMW, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( rightExtend, sigInPlusOne );
|
|
break;
|
|
}
|
|
case ASYMH:
|
|
{
|
|
RightASYMH worklet( sigInLen + 1 );
|
|
vtkm::worklet::DispatcherMapField< RightASYMH, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( rightExtend, sigInPlusOne );
|
|
break;
|
|
}
|
|
case ASYMW:
|
|
{
|
|
RightASYMW worklet( sigInLen + 1 );
|
|
vtkm::worklet::DispatcherMapField< RightASYMW, DeviceTag > dispatcher( worklet );
|
|
dispatcher.Invoke( rightExtend, sigInPlusOne );
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
vtkm::cont::ErrorControlInternal("Right extension mode not supported!");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
// make a copy of rightExtend with a zero attached to the left
|
|
ExtensionArrayType rightExtendPlusOne;
|
|
rightExtendPlusOne.PrepareForOutput( addLen + 1, DeviceTag() );
|
|
WaveletBase::DeviceCopyStartX( rightExtend, rightExtendPlusOne, 1, DeviceTag() );
|
|
WaveletBase::DeviceAssignZero( rightExtendPlusOne, 0, DeviceTag() );
|
|
rightExtend = rightExtendPlusOne ;
|
|
}
|
|
|
|
ArrayConcat leftOn( leftExtend, sigIn );
|
|
sigOut = vtkm::cont::make_ArrayHandleConcatenate( leftOn, rightExtend );
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
// Performs one level of 1D discrete wavelet transform
|
|
// It takes care of boundary conditions, etc.
|
|
template< typename SignalArrayType, typename CoeffArrayType, typename DeviceTag>
|
|
FLOAT_64 DWT1D( const SignalArrayType &sigIn, // Input
|
|
CoeffArrayType &coeffOut, // Output: cA followed by cD
|
|
std::vector<vtkm::Id> &L, // Output: how many cA and cD.
|
|
DeviceTag )
|
|
{
|
|
vtkm::Id sigInLen = sigIn.GetNumberOfValues();
|
|
if( GetWaveletMaxLevel( sigInLen ) < 1 )
|
|
{
|
|
vtkm::cont::ErrorControlInternal( "Signal is too short to perform DWT!" );
|
|
return -1;
|
|
}
|
|
|
|
VTKM_ASSERT( L.size() == 3 );
|
|
L[0] = WaveletBase::GetApproxLength( sigInLen );
|
|
L[1] = WaveletBase::GetDetailLength( sigInLen );
|
|
L[2] = sigInLen;
|
|
|
|
VTKM_ASSERT( L[0] + L[1] == L[2] );
|
|
|
|
vtkm::Id filterLen = WaveletBase::filter.GetFilterLength();
|
|
|
|
bool doSymConv = false;
|
|
if( WaveletBase::filter.isSymmetric() )
|
|
{
|
|
if( ( WaveletBase::wmode == SYMW && ( filterLen % 2 != 0 ) ) ||
|
|
( WaveletBase::wmode == SYMH && ( filterLen % 2 == 0 ) ) )
|
|
doSymConv = true;
|
|
}
|
|
|
|
vtkm::Id sigConvolvedLen = L[0] + L[1]; // approx + detail coeffs
|
|
vtkm::Id addLen; // for extension
|
|
bool oddLow = true;
|
|
bool oddHigh = true;
|
|
if( filterLen % 2 != 0 )
|
|
oddLow = false;
|
|
if( doSymConv )
|
|
{
|
|
addLen = filterLen / 2;
|
|
if( sigInLen % 2 != 0 )
|
|
sigConvolvedLen += 1;
|
|
}
|
|
else
|
|
addLen = filterLen - 1;
|
|
|
|
vtkm::Id sigExtendedLen = sigInLen + 2 * addLen;
|
|
|
|
typedef typename SignalArrayType::ValueType SigInValueType;
|
|
typedef vtkm::cont::ArrayHandle<SigInValueType> SigInBasic;
|
|
|
|
typedef vtkm::cont::ArrayHandleConcatenate< SigInBasic, SignalArrayType >
|
|
ConcatType1;
|
|
typedef vtkm::cont::ArrayHandleConcatenate< ConcatType1, SigInBasic >
|
|
ConcatType2;
|
|
|
|
ConcatType2 sigInExtended;
|
|
|
|
this->Extend1D( sigIn, sigInExtended, addLen, WaveletBase::wmode,
|
|
WaveletBase::wmode, false, false, DeviceTag() );
|
|
VTKM_ASSERT( sigInExtended.GetNumberOfValues() == sigExtendedLen );
|
|
|
|
// initialize a worklet for forward transform
|
|
vtkm::worklet::wavelets::ForwardTransform<DeviceTag> forwardTransform
|
|
( WaveletBase::filter.GetLowDecomposeFilter(),
|
|
WaveletBase::filter.GetHighDecomposeFilter(),
|
|
filterLen, L[0], L[1], oddLow, oddHigh );
|
|
|
|
coeffOut.PrepareForOutput( sigExtendedLen, DeviceTag() );
|
|
vtkm::worklet::DispatcherMapField<vtkm::worklet::wavelets::ForwardTransform<DeviceTag>, DeviceTag>
|
|
dispatcher(forwardTransform);
|
|
// put a timer
|
|
vtkm::cont::Timer<DeviceTag> timer;
|
|
dispatcher.Invoke( sigInExtended,
|
|
coeffOut );
|
|
vtkm::Float64 elapsedTime = timer.GetElapsedTime();
|
|
|
|
VTKM_ASSERT( L[0] + L[1] <= coeffOut.GetNumberOfValues() );
|
|
coeffOut.Shrink( L[0] + L[1] );
|
|
|
|
return elapsedTime;
|
|
}
|
|
|
|
|
|
|
|
// Performs one level of inverse wavelet transform
|
|
// It takes care of boundary conditions, etc.
|
|
template< typename CoeffArrayType, typename SignalArrayType, typename DeviceTag >
|
|
FLOAT_64 IDWT1D( const CoeffArrayType &coeffIn, // Input, cA followed by cD
|
|
std::vector<vtkm::Id> &L, // Input, how many cA and cD
|
|
SignalArrayType &sigOut, // Output
|
|
DeviceTag )
|
|
{
|
|
VTKM_ASSERT( L.size() == 3 );
|
|
VTKM_ASSERT( L[2] == coeffIn.GetNumberOfValues() );
|
|
|
|
vtkm::Id filterLen = WaveletBase::filter.GetFilterLength();
|
|
bool doSymConv = false;
|
|
vtkm::worklet::wavelets::DWTMode cALeftMode = WaveletBase::wmode;
|
|
vtkm::worklet::wavelets::DWTMode cARightMode = WaveletBase::wmode;
|
|
vtkm::worklet::wavelets::DWTMode cDLeftMode = WaveletBase::wmode;
|
|
vtkm::worklet::wavelets::DWTMode cDRightMode = WaveletBase::wmode;
|
|
|
|
if( WaveletBase::filter.isSymmetric() ) // this is always true with the 1st 4 filters.
|
|
{
|
|
if(( WaveletBase::wmode == SYMW && (filterLen % 2 != 0) ) ||
|
|
( WaveletBase::wmode == SYMH && (filterLen % 2 == 0) ) )
|
|
{
|
|
doSymConv = true; // doSymConv is always true with the 1st 4 filters.
|
|
|
|
if( WaveletBase::wmode == SYMH )
|
|
{
|
|
cDLeftMode = ASYMH;
|
|
if( L[2] % 2 != 0 )
|
|
{
|
|
cARightMode = SYMW;
|
|
cDRightMode = ASYMW;
|
|
}
|
|
else
|
|
cDRightMode = ASYMH;
|
|
}
|
|
else
|
|
{
|
|
cDLeftMode = SYMH;
|
|
if( L[2] % 2 != 0 )
|
|
{
|
|
cARightMode = SYMW;
|
|
cDRightMode = SYMH;
|
|
}
|
|
else
|
|
cARightMode = SYMH;
|
|
}
|
|
}
|
|
}
|
|
|
|
vtkm::Id cATempLen, cDTempLen; //, reconTempLen;
|
|
vtkm::Id addLen = 0;
|
|
vtkm::Id cDPadLen = 0;
|
|
if( doSymConv ) // extend cA and cD
|
|
{
|
|
addLen = filterLen / 4; // addLen == 0 for Haar kernel
|
|
if( (L[0] > L[1]) && (WaveletBase::wmode == SYMH) )
|
|
cDPadLen = L[0];
|
|
|
|
cATempLen = L[0] + 2 * addLen;
|
|
cDTempLen = cATempLen; // same length
|
|
}
|
|
else // not extend cA and cD
|
|
{ // (biorthogonal kernels won't come into this case)
|
|
cATempLen = L[0];
|
|
cDTempLen = L[1];
|
|
}
|
|
|
|
typedef vtkm::cont::ArrayHandleCounting< vtkm::Id > IdArrayType;
|
|
typedef vtkm::cont::ArrayHandlePermutation< IdArrayType, CoeffArrayType >
|
|
PermutArrayType;
|
|
|
|
// Separate cA and cD
|
|
IdArrayType approxIndices( 0, 1, L[0] );
|
|
IdArrayType detailIndices( L[0], 1, L[1] );
|
|
PermutArrayType cA( approxIndices, coeffIn );
|
|
PermutArrayType cD( detailIndices, coeffIn );
|
|
|
|
typedef typename CoeffArrayType::ValueType CoeffValueType;
|
|
typedef vtkm::cont::ArrayHandle< CoeffValueType > ExtensionArrayType;
|
|
typedef vtkm::cont::ArrayHandleConcatenate< ExtensionArrayType, PermutArrayType >
|
|
Concat1;
|
|
typedef vtkm::cont::ArrayHandleConcatenate< Concat1, ExtensionArrayType >
|
|
Concat2;
|
|
|
|
Concat2 cATemp, cDTemp;
|
|
|
|
if( doSymConv ) // Actually extend cA and cD
|
|
{
|
|
// first extend cA to be cATemp
|
|
this->Extend1D( cA, cATemp, addLen, cALeftMode, cARightMode, false, false, DeviceTag() );
|
|
|
|
// Then extend cD based on extension needs
|
|
if( cDPadLen > 0 )
|
|
{
|
|
// Add back the missing final cD, 0.0, before doing extension
|
|
this->Extend1D( cD, cDTemp, addLen, cDLeftMode, cDRightMode, true, false, DeviceTag() );
|
|
}
|
|
else
|
|
{
|
|
vtkm::Id cDTempLenWouldBe = L[1] + 2 * addLen;
|
|
if( cDTempLenWouldBe == cDTempLen )
|
|
{
|
|
this->Extend1D( cD, cDTemp, addLen, cDLeftMode, cDRightMode, false, false, DeviceTag());
|
|
}
|
|
else if( cDTempLenWouldBe == cDTempLen - 1 )
|
|
{
|
|
this->Extend1D( cD, cDTemp, addLen, cDLeftMode, cDRightMode, false, true , DeviceTag());
|
|
}
|
|
else
|
|
{
|
|
vtkm::cont::ErrorControlInternal("cDTemp Length not match!");
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// make cATemp
|
|
ExtensionArrayType dummyArray;
|
|
dummyArray.PrepareForOutput(0, DeviceTag() );
|
|
Concat1 cALeftOn( dummyArray, cA );
|
|
cATemp = vtkm::cont::make_ArrayHandleConcatenate< Concat1, ExtensionArrayType >
|
|
( cALeftOn, dummyArray );
|
|
|
|
// make cDTemp
|
|
Concat1 cDLeftOn( dummyArray, cD );
|
|
cDTemp = vtkm::cont::make_ArrayHandleConcatenate< Concat1, ExtensionArrayType >
|
|
( cDLeftOn, dummyArray );
|
|
}
|
|
|
|
// make sure signal extension went as expected
|
|
VTKM_ASSERT( cATemp.GetNumberOfValues() == cATempLen );
|
|
VTKM_ASSERT( cDTemp.GetNumberOfValues() == cDTempLen );
|
|
|
|
vtkm::cont::ArrayHandleConcatenate< Concat2, Concat2>
|
|
coeffInExtended( cATemp, cDTemp );
|
|
|
|
// Allocate memory for sigOut
|
|
sigOut.PrepareForOutput( cATempLen + cDTempLen, DeviceTag() );
|
|
|
|
vtkm::Float64 elapsedTime = 0;
|
|
if( filterLen % 2 != 0 )
|
|
{
|
|
vtkm::worklet::wavelets::InverseTransformOdd<DeviceTag> inverseXformOdd
|
|
( WaveletBase::filter.GetLowReconstructFilter(),
|
|
WaveletBase::filter.GetHighReconstructFilter(),
|
|
filterLen, L[0], cATempLen );
|
|
vtkm::worklet::DispatcherMapField<vtkm::worklet::wavelets::
|
|
InverseTransformOdd<DeviceTag>, DeviceTag> dispatcher( inverseXformOdd );
|
|
// use a timer
|
|
vtkm::cont::Timer<DeviceTag> timer;
|
|
dispatcher.Invoke( coeffInExtended, sigOut );
|
|
elapsedTime = timer.GetElapsedTime();
|
|
}
|
|
else
|
|
{
|
|
vtkm::worklet::wavelets::InverseTransformEven<DeviceTag> inverseXformEven
|
|
( WaveletBase::filter.GetLowReconstructFilter(),
|
|
WaveletBase::filter.GetHighReconstructFilter(),
|
|
filterLen, L[0], cATempLen, !doSymConv );
|
|
vtkm::worklet::DispatcherMapField<vtkm::worklet::wavelets::
|
|
InverseTransformEven<DeviceTag>, DeviceTag> dispatcher( inverseXformEven );
|
|
// use a timer
|
|
vtkm::cont::Timer<DeviceTag> timer;
|
|
dispatcher.Invoke( coeffInExtended, sigOut );
|
|
elapsedTime = timer.GetElapsedTime();
|
|
}
|
|
|
|
sigOut.Shrink( L[2] );
|
|
|
|
return elapsedTime;
|
|
}
|
|
|
|
|
|
|
|
// Performs one level of 2D discrete wavelet transform
|
|
// It takes care of boundary conditions, etc.
|
|
// N.B.
|
|
// L[0] == L[2]
|
|
// L[1] == L[5]
|
|
// L[3] == L[7]
|
|
// L[4] == L[6]
|
|
//
|
|
// ____L[0]_______L[4]____
|
|
// | | |
|
|
// L[1] | cA | cDv | L[5]
|
|
// | (LL) | (HL) |
|
|
// | | |
|
|
// |---------------------|
|
|
// | | |
|
|
// | cDh | cDd | L[7]
|
|
// L[3] | (LH) | (HH) |
|
|
// | | |
|
|
// |__________|__________|
|
|
// L[2] L[6]
|
|
//
|
|
// Performs one level of 2D discrete wavelet transform on a small rectangle of input array
|
|
// The output has the same size as the small rectangle
|
|
template< typename ArrayInType, typename ArrayOutType, typename DeviceTag >
|
|
FLOAT_64 DWT2D ( const ArrayInType &sigIn,
|
|
vtkm::Id sigDimX,
|
|
vtkm::Id sigDimY,
|
|
vtkm::Id sigStartX,
|
|
vtkm::Id sigStartY,
|
|
vtkm::Id sigPretendDimX,
|
|
vtkm::Id sigPretendDimY,
|
|
ArrayOutType &coeffOut,
|
|
std::vector<vtkm::Id> &L,
|
|
DeviceTag )
|
|
{
|
|
VTKM_ASSERT( sigDimX * sigDimY == sigIn.GetNumberOfValues() );
|
|
|
|
VTKM_ASSERT( L.size() == 10 );
|
|
L[0] = WaveletBase::GetApproxLength( sigPretendDimX ); L[2] = L[0];
|
|
L[1] = WaveletBase::GetApproxLength( sigPretendDimY ); L[5] = L[1];
|
|
L[3] = WaveletBase::GetDetailLength( sigPretendDimY ); L[7] = L[3];
|
|
L[4] = WaveletBase::GetDetailLength( sigPretendDimX ); L[6] = L[4];
|
|
L[8] = sigPretendDimX;
|
|
L[9] = sigPretendDimY;
|
|
|
|
vtkm::Id filterLen = WaveletBase::filter.GetFilterLength();
|
|
bool oddLow = true;
|
|
if( filterLen % 2 != 0 )
|
|
oddLow = false;
|
|
vtkm::Id addLen = filterLen / 2;
|
|
|
|
typedef typename ArrayInType::ValueType ValueType;
|
|
typedef vtkm::cont::ArrayHandle<ValueType> ArrayType;
|
|
typedef vtkm::worklet::wavelets::ForwardTransform2D<DeviceTag> ForwardXForm;
|
|
typedef typename vtkm::worklet::DispatcherMapField< ForwardXForm, DeviceTag >
|
|
DispatcherType;
|
|
|
|
vtkm::cont::Timer<DeviceTag> timer;
|
|
vtkm::Float64 computationTime = 0.0;
|
|
|
|
ArrayType afterX;
|
|
afterX.PrepareForOutput( sigPretendDimX * sigPretendDimY, DeviceTag() );
|
|
|
|
// First transform on rows
|
|
{
|
|
ArrayType leftExt, rightExt;
|
|
this->Extend2D ( sigIn,
|
|
sigDimX, sigDimY,
|
|
sigStartX, sigStartY,
|
|
sigPretendDimX, sigPretendDimY,
|
|
leftExt, rightExt, addLen,
|
|
WaveletBase::wmode, WaveletBase::wmode, false, false,
|
|
true, DeviceTag() ); // Extend in left-right direction
|
|
ForwardXForm worklet( WaveletBase::filter.GetLowDecomposeFilter(),
|
|
WaveletBase::filter.GetHighDecomposeFilter(),
|
|
filterLen, L[0], oddLow, true, // left-right
|
|
addLen, sigPretendDimY,
|
|
sigDimX, sigDimY,
|
|
sigStartX, sigStartY,
|
|
sigPretendDimX, sigPretendDimY,
|
|
addLen, sigPretendDimY );
|
|
DispatcherType dispatcher(worklet);
|
|
timer.Reset();
|
|
dispatcher.Invoke( leftExt, sigIn, rightExt, afterX );
|
|
computationTime += timer.GetElapsedTime();
|
|
}
|
|
|
|
// Then do transform in Y direction
|
|
{
|
|
ArrayType topExt, bottomExt;
|
|
coeffOut.PrepareForOutput( sigPretendDimX * sigPretendDimY, DeviceTag() );
|
|
this->Extend2D ( afterX,
|
|
sigPretendDimX, sigPretendDimY,
|
|
0, 0,
|
|
sigPretendDimX, sigPretendDimY,
|
|
topExt, bottomExt, addLen,
|
|
WaveletBase::wmode, WaveletBase::wmode, false, false,
|
|
false, DeviceTag() ); // Extend in top-down direction
|
|
ForwardXForm worklet( WaveletBase::filter.GetLowDecomposeFilter(),
|
|
WaveletBase::filter.GetHighDecomposeFilter(),
|
|
filterLen, L[1], oddLow, false, // top-down
|
|
sigPretendDimX, addLen,
|
|
sigPretendDimX, sigPretendDimY,
|
|
0, 0,
|
|
sigPretendDimX, sigPretendDimY,
|
|
sigPretendDimX, addLen );
|
|
DispatcherType dispatcher( worklet );
|
|
timer.Reset();
|
|
dispatcher.Invoke( topExt, afterX, bottomExt, coeffOut );
|
|
computationTime += timer.GetElapsedTime();
|
|
}
|
|
|
|
return computationTime;
|
|
}
|
|
|
|
|
|
|
|
// Performs one level of IDWT.
|
|
// The output array has the same dimensions as the small rectangle.
|
|
template< typename ArrayInType, typename ArrayOutType, typename DeviceTag >
|
|
FLOAT_64 IDWT2D ( const ArrayInType &coeffIn,
|
|
vtkm::Id inDimX,
|
|
vtkm::Id inDimY,
|
|
vtkm::Id inStartX,
|
|
vtkm::Id inStartY,
|
|
const std::vector<vtkm::Id> &L,
|
|
ArrayOutType &sigOut,
|
|
DeviceTag )
|
|
{
|
|
VTKM_ASSERT( L.size() == 10 );
|
|
VTKM_ASSERT( inDimX * inDimY == coeffIn.GetNumberOfValues() );
|
|
vtkm::Id inPretendDimX = L[0] + L[4];
|
|
vtkm::Id inPretendDimY = L[1] + L[3];
|
|
|
|
vtkm::Id filterLen = WaveletBase::filter.GetFilterLength();
|
|
typedef vtkm::cont::ArrayHandle<typename ArrayInType::ValueType> BasicArrayType;
|
|
typedef vtkm::worklet::wavelets::InverseTransform2D<DeviceTag> IDWT2DWorklet;
|
|
typedef vtkm::worklet::DispatcherMapField<IDWT2DWorklet, DeviceTag> Dispatcher;
|
|
vtkm::cont::Timer<DeviceTag> timer;
|
|
vtkm::Float64 computationTime = 0.0;
|
|
|
|
// First inverse transform on columns
|
|
BasicArrayType afterY;
|
|
{
|
|
BasicArrayType ext1, ext2, ext3, ext4;
|
|
vtkm::Id extDimX = inPretendDimX;
|
|
vtkm::Id ext1DimY, ext2DimY, ext3DimY, ext4DimY;
|
|
this->IDWTHelperTD( coeffIn, inDimX, inDimY, inStartX, inStartY,
|
|
inPretendDimX, inPretendDimY, L[1], L[3],
|
|
ext1, ext2, ext3, ext4, ext1DimY, ext2DimY, ext3DimY, ext4DimY,
|
|
filterLen, wmode, DeviceTag() );
|
|
|
|
afterY.PrepareForOutput( inPretendDimX * inPretendDimY, DeviceTag() );
|
|
IDWT2DWorklet worklet( WaveletBase::filter.GetLowReconstructFilter(),
|
|
WaveletBase::filter.GetHighReconstructFilter(),
|
|
filterLen,
|
|
extDimX, ext1DimY, // ext1
|
|
inPretendDimX, L[1], // cA
|
|
extDimX, ext2DimY, // ext2
|
|
extDimX, ext3DimY, // ext3
|
|
inPretendDimX, L[3], // cD
|
|
extDimX, ext4DimY, // ext4
|
|
inDimX, inDimY, // coeffIn
|
|
inStartX, inStartY, // coeffIn
|
|
false ); // top-down
|
|
Dispatcher dispatcher( worklet );
|
|
timer.Reset();
|
|
dispatcher.Invoke( ext1, ext2, ext3, ext4, coeffIn, afterY );
|
|
computationTime += timer.GetElapsedTime();
|
|
}
|
|
|
|
// Then inverse transform on rows
|
|
{
|
|
BasicArrayType ext1, ext2, ext3, ext4;
|
|
vtkm::Id extDimY = inPretendDimY;
|
|
vtkm::Id ext1DimX, ext2DimX, ext3DimX, ext4DimX;
|
|
this->IDWTHelperLR( afterY, inPretendDimX, inPretendDimY, 0, 0,
|
|
inPretendDimX, inPretendDimY, L[0], L[4],
|
|
ext1, ext2, ext3, ext4, ext1DimX, ext2DimX, ext3DimX, ext4DimX,
|
|
filterLen, wmode, DeviceTag() );
|
|
sigOut.PrepareForOutput( inPretendDimX * inPretendDimY, DeviceTag() );
|
|
IDWT2DWorklet worklet( WaveletBase::filter.GetLowReconstructFilter(),
|
|
WaveletBase::filter.GetHighReconstructFilter(),
|
|
filterLen,
|
|
ext1DimX, extDimY, // ext1
|
|
L[0], inPretendDimY, // cA
|
|
ext2DimX, extDimY, // ext2
|
|
ext3DimX, extDimY, // ext3
|
|
L[4], inPretendDimY, // cA
|
|
ext4DimX, extDimY, // ext4
|
|
inPretendDimX, inPretendDimY,
|
|
0, 0,
|
|
true ); // left-right
|
|
Dispatcher dispatcher( worklet );
|
|
timer.Reset();
|
|
dispatcher.Invoke( ext1, ext2, ext3, ext4, afterY, sigOut );
|
|
computationTime += timer.GetElapsedTime();
|
|
}
|
|
|
|
return computationTime;
|
|
}
|
|
|
|
|
|
|
|
// decides the correct extension modes for cA and cD separately,
|
|
// and fill the extensions.
|
|
template< typename ArrayInType, typename ArrayOutType, typename DeviceTag >
|
|
void IDWTHelperLR( const ArrayInType &coeffIn,
|
|
vtkm::Id inDimX,
|
|
vtkm::Id inDimY,
|
|
vtkm::Id inStartX,
|
|
vtkm::Id inStartY,
|
|
vtkm::Id inPretendDimX,
|
|
vtkm::Id inPretendDimY,
|
|
vtkm::Id cADimX, // of codffIn
|
|
vtkm::Id cDDimX, // of codffIn
|
|
ArrayOutType &ext1, // output
|
|
ArrayOutType &ext2, // output
|
|
ArrayOutType &ext3, // output
|
|
ArrayOutType &ext4, // output
|
|
vtkm::Id &ext1DimX, // output
|
|
vtkm::Id &ext2DimX, // output
|
|
vtkm::Id &ext3DimX, // output
|
|
vtkm::Id &ext4DimX, // output
|
|
vtkm::Id filterLen,
|
|
DWTMode mode,
|
|
DeviceTag )
|
|
{
|
|
VTKM_ASSERT( inPretendDimX = cADimX + cDDimX );
|
|
|
|
// determine extension modes
|
|
DWTMode cALeft, cARight, cDLeft, cDRight;
|
|
cALeft = cARight = cDLeft = cDRight = mode;
|
|
if( mode == SYMH )
|
|
{
|
|
cDLeft = ASYMH;
|
|
if( inPretendDimX % 2 != 0 )
|
|
{
|
|
cARight = SYMW;
|
|
cDRight = ASYMW;
|
|
}
|
|
else
|
|
cDRight = ASYMH;
|
|
}
|
|
else // mode == SYMW
|
|
{
|
|
cDLeft = SYMH;
|
|
if( inPretendDimX % 2 != 0 )
|
|
{
|
|
cARight = SYMW;
|
|
cDRight = SYMH;
|
|
}
|
|
else
|
|
cARight = SYMH;
|
|
}
|
|
// determine length after extension
|
|
vtkm::Id cAExtendedDimX, cDExtendedDimX;
|
|
vtkm::Id cDPadLen = 0;
|
|
vtkm::Id addLen = filterLen / 4; // addLen == 0 for Haar kernel
|
|
if( (cADimX > cDDimX) && (mode == SYMH) )
|
|
cDPadLen = cADimX;
|
|
cAExtendedDimX = cADimX + 2 * addLen;
|
|
cDExtendedDimX = cAExtendedDimX;
|
|
|
|
// extend cA
|
|
vtkm::Id cADimY = inPretendDimY;
|
|
this->Extend2D ( coeffIn, inDimX, inDimY, inStartX, inStartY, cADimX, cADimY,
|
|
ext1, ext2, addLen, cALeft, cARight,
|
|
false, false, true, DeviceTag() );
|
|
|
|
ext1DimX = ext2DimX = addLen;
|
|
|
|
// extend cD
|
|
vtkm::Id cDDimY = inPretendDimY;
|
|
if( cDPadLen > 0 )
|
|
{
|
|
this->Extend2D ( coeffIn, inDimX, inDimY, inStartX + cADimX, inStartY,
|
|
cDDimX, cDDimY, ext3, ext4, addLen, cDLeft, cDRight,
|
|
true, false, true, DeviceTag() );
|
|
ext3DimX = addLen;
|
|
ext4DimX = addLen + 1;
|
|
}
|
|
else
|
|
{
|
|
vtkm::Id cDExtendedWouldBe = cDDimX + 2 * addLen;
|
|
if( cDExtendedWouldBe == cDExtendedDimX )
|
|
{
|
|
this->Extend2D ( coeffIn, inDimX, inDimY, inStartX + cADimX, inStartY,
|
|
cDDimX, cDDimY, ext3, ext4, addLen, cDLeft, cDRight,
|
|
false, false, true, DeviceTag());
|
|
ext3DimX = ext4DimX = addLen;
|
|
}
|
|
else if( cDExtendedWouldBe == cDExtendedDimX - 1 )
|
|
{
|
|
this->Extend2D ( coeffIn, inDimX, inDimY, inStartX + cADimX, inStartY,
|
|
cDDimX, cDDimY, ext3, ext4, addLen, cDLeft, cDRight,
|
|
false, true, true, DeviceTag());
|
|
ext3DimX = addLen;
|
|
ext4DimX = addLen + 1;
|
|
}
|
|
else
|
|
vtkm::cont::ErrorControlInternal("cDTemp Length not match!");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// decides the correct extension modes for cA and cD separately,
|
|
// and fill the extensions.
|
|
template< typename ArrayInType, typename ArrayOutType, typename DeviceTag >
|
|
void IDWTHelperTD( const ArrayInType &coeffIn,
|
|
vtkm::Id inDimX,
|
|
vtkm::Id inDimY,
|
|
vtkm::Id inStartX,
|
|
vtkm::Id inStartY,
|
|
vtkm::Id inPretendDimX,
|
|
vtkm::Id inPretendDimY,
|
|
vtkm::Id cADimY, // of codffIn
|
|
vtkm::Id cDDimY, // of codffIn
|
|
ArrayOutType &ext1, // output
|
|
ArrayOutType &ext2, // output
|
|
ArrayOutType &ext3, // output
|
|
ArrayOutType &ext4, // output
|
|
vtkm::Id &ext1DimY, // output
|
|
vtkm::Id &ext2DimY, // output
|
|
vtkm::Id &ext3DimY, // output
|
|
vtkm::Id &ext4DimY, // output
|
|
vtkm::Id filterLen,
|
|
DWTMode mode,
|
|
DeviceTag )
|
|
{
|
|
VTKM_ASSERT( inPretendDimY = cADimY + cDDimY );
|
|
|
|
// determine extension modes
|
|
DWTMode cATop, cABottom, cDTop, cDBottom;
|
|
cATop = cABottom = cDTop = cDBottom = mode;
|
|
if( mode == SYMH )
|
|
{
|
|
cDTop = ASYMH;
|
|
if( inPretendDimY % 2 != 0 )
|
|
{
|
|
cABottom = SYMW;
|
|
cDBottom = ASYMW;
|
|
}
|
|
else
|
|
cDBottom = ASYMH;
|
|
}
|
|
else // mode == SYMW
|
|
{
|
|
cDTop = SYMH;
|
|
if( inPretendDimY % 2 != 0 )
|
|
{
|
|
cABottom = SYMW;
|
|
cDBottom = SYMH;
|
|
}
|
|
else
|
|
cABottom = SYMH;
|
|
}
|
|
// determine length after extension
|
|
vtkm::Id cAExtendedDimY, cDExtendedDimY;
|
|
vtkm::Id cDPadLen = 0;
|
|
vtkm::Id addLen = filterLen / 4; // addLen == 0 for Haar kernel
|
|
if( (cADimY > cDDimY) && (mode == SYMH) )
|
|
cDPadLen = cADimY;
|
|
cAExtendedDimY = cADimY + 2 * addLen;
|
|
cDExtendedDimY = cAExtendedDimY;
|
|
|
|
// extend cA
|
|
vtkm::Id cADimX = inPretendDimX;
|
|
this->Extend2D ( coeffIn, inDimX, inDimY, inStartX, inStartY, cADimX, cADimY,
|
|
ext1, ext2, addLen, cATop, cABottom,
|
|
false, false, false, DeviceTag() );
|
|
ext1DimY = ext2DimY = addLen;
|
|
|
|
// extend cD
|
|
vtkm::Id cDDimX = inPretendDimX;
|
|
if( cDPadLen > 0 )
|
|
{
|
|
this->Extend2D ( coeffIn, inDimX, inDimY, inStartX, inStartY + cADimY,
|
|
cDDimX, cDDimY, ext3, ext4, addLen, cDTop, cDBottom,
|
|
true, false, false, DeviceTag() );
|
|
ext3DimY = addLen;
|
|
ext4DimY = addLen + 1;
|
|
}
|
|
else
|
|
{
|
|
vtkm::Id cDExtendedWouldBe = cDDimY + 2 * addLen;
|
|
if( cDExtendedWouldBe == cDExtendedDimY )
|
|
{
|
|
this->Extend2D ( coeffIn, inDimX, inDimY, inStartX, inStartY + cADimY,
|
|
cDDimX, cDDimY, ext3, ext4, addLen, cDTop, cDBottom,
|
|
false, false, false, DeviceTag());
|
|
ext3DimY = ext4DimY = addLen;
|
|
}
|
|
else if( cDExtendedWouldBe == cDExtendedDimY - 1 )
|
|
{
|
|
this->Extend2D ( coeffIn, inDimX, inDimY, inStartX, inStartY + cADimY,
|
|
cDDimX, cDDimY, ext3, ext4, addLen, cDTop, cDBottom,
|
|
false, true, false, DeviceTag());
|
|
ext3DimY = addLen;
|
|
ext4DimY = addLen + 1;
|
|
}
|
|
else
|
|
vtkm::cont::ErrorControlInternal("cDTemp Length not match!");
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
} // namespace wavelets
|
|
} // namespace worklet
|
|
} // namespace vtkm
|
|
|
|
#endif
|