void apply( void ) { const kvs::RendererBase* base = static_cast<kvs::glut::Screen*>(screen())->scene()->rendererManager()->renderer(); kvs::RayCastingRenderer* renderer = (kvs::RayCastingRenderer*)base; renderer->setTransferFunction( transferFunction() ); screen()->redraw(); }
double Neuron::count(double* input) { static double result; result = this->_activationFunction( transferFunction(input) ); return result; }
bool transferValue(lua_State* toL, lua_State* fromL) { bool result = false; int type = lua_type(fromL, -1); switch (type) { case LUA_TNIL: lua_pushnil(toL); result = true; break; case LUA_TNUMBER: lua_pushnumber(toL, lua_tonumber(fromL, -1)); result = true; break; case LUA_TBOOLEAN: lua_pushboolean(toL, lua_toboolean(fromL, -1)); result = true; break; case LUA_TSTRING: { size_t len; const char* str = lua_tolstring(fromL, -1, &len); lua_pushlstring(toL, str, len); result = true; break; } case LUA_TTABLE: result = transferTable(toL, fromL); break; case LUA_TFUNCTION: result = transferFunction(toL, fromL); break; case LUA_TUSERDATA: { Userdata* ud = getPrivateUserdata(fromL, -1); if (ud) result = ud->copyToState(toL); break; } case LUA_TTHREAD: // copying coroutines is not supported. break; case LUA_TLIGHTUSERDATA: lua_pushlightuserdata(toL, lua_touserdata(fromL, -1)); result = true; break; default: break; } return result; }
void ProjectionFilterer_fftw<TProjection>::Initialize() { athabasca_assert(!this->m_ForwardPlan); athabasca_assert(!this->m_BackwardPlan); // Add one to next power of two in order to pad. this->m_FFTLength = bonelab::FFT_util::NextNumberWithFactors2And3(2*this->m_Dimensions[1]); // Buffer length is slightly longer due to FFTW storage scheme. unsigned int bufferLength = 2*(this->m_FFTLength/2 + 1); this->m_Buffer.construct(bufferLength); m_ForwardPlan = fftw_mt<TValue>::plan_dft_r2c_1d( this->m_FFTLength, this->m_Buffer.ptr(), reinterpret_cast<typename fftw_mt<TValue>::complex*>(this->m_Buffer.ptr()), FFTW_MEASURE); m_BackwardPlan = fftw_mt<TValue>::plan_dft_c2r_1d( this->m_FFTLength, reinterpret_cast<typename fftw_mt<TValue>::complex*>(this->m_Buffer.ptr()), this->m_Buffer.ptr(), FFTW_MEASURE); this->m_RampFilter.construct(bufferLength); // Create another array that is just a reference to the same data, // but with length just FFTLength, instead of length Buffer. TFunction1D rampFilterRef; rampFilterRef.construct_reference(this->m_RampFilter.ptr(), this->m_FFTLength); // Create Ramp Filter by transforming real space version RampFilterRealSpace<TFunction1D> rampFilterGenerator; rampFilterGenerator.SetLength(this->m_FFTLength); rampFilterGenerator.SetSpacing(this->m_PixelSpacing); // Calculate the factor. This consists of: // 1. In the FFTW library, the inverse FFT should be // multiplied by the 1/FFTLength. double factor = this->m_Weight/(this->m_FFTLength); rampFilterGenerator.SetWeight(factor); rampFilterGenerator.ConstructRealSpaceFilter(rampFilterRef); // performance check athabasca_assert(size_t(m_RampFilter.ptr()) % 16 == 0); /* to the frequency domain */ typename fftw_mt<TValue>::plan rampForwardPlan = fftw_mt<TValue>::plan_dft_r2c_1d( this->m_FFTLength, this->m_RampFilter.ptr(), reinterpret_cast<typename fftw_mt<TValue>::complex*>(this->m_RampFilter.ptr()), FFTW_ESTIMATE); fftw_mt<TValue>::execute(rampForwardPlan); fftw_mt<TValue>::destroy_plan(rampForwardPlan); if (this->m_SmoothingFilter) { // Note: We will construct transferFunction out to this->m_FFTLength, // which is in fact more than we really need. However, as the // length also indicates the Nyquist frequency, this is necessary // for correctness. TFunction1D transferFunction(this->m_FFTLength); this->m_SmoothingFilter->SetLength(this->m_FFTLength); this->m_SmoothingFilter->ConstructTransferFunction(transferFunction); // Multiply RampFilter by transferFunction for (unsigned int i=0, j=0; j<bufferLength; ++i, j+=2) { // Note that these are only the real components. // Just assume that m_RampFilter has no imaginary part - actually even // if it does, it is ignored below. this->m_RampFilter[j] *= transferFunction[i]; } } }
void ProjectionFilterer_vDSP<TProjection>::Initialize() { athabasca_assert(!this->m_FFTsetup); athabasca_assert(!this->m_Scratch); athabasca_assert(!this->m_RampFilter); athabasca_assert(this->m_Weight > 0); // Add one to next power of two in order to pad. this->m_PowerOfTwo = bonelab::FFT_util::NextPowerOfTwo(this->m_Dimensions[1]) + 1; // #define EXTRA_FFT_PADDING #ifdef EXTRA_FFT_PADDING std::cout << "**** WARNING: Adding extra FFT padding!\n"; this->m_PowerOfTwo++; #endif this->m_FFTLength = 1 << this->m_PowerOfTwo; this->m_FFTsetup = bonelab::vDSP<TValue>::create_fftsetup(this->m_PowerOfTwo, 0); this->m_Scratch = new TSplitComplex; this->m_Scratch->realp = (TValue*)malloc(this->m_FFTLength * sizeof(TValue)); this->m_Scratch->imagp = this->m_Scratch->realp + this->m_FFTLength/2; this->m_RampFilter = new TSplitComplex; this->m_RampFilter->realp = (TValue*)malloc(this->m_FFTLength * sizeof(TValue)); this->m_RampFilter->imagp = this->m_RampFilter->realp + this->m_FFTLength/2; // Create Ramp Filter by transforming real space version TFunction1D rampFilterRealSpace(this->m_FFTLength); RampFilterRealSpace<TFunction1D> rampFilterGenerator; rampFilterGenerator.SetLength(this->m_FFTLength); rampFilterGenerator.SetSpacing(this->m_PixelSpacing); // Calculate the factor. This consists of: // 1. In the vDSP library, the inverse FFT should be // multiplied by the 1/(2*FFTLength). Actually, experimentation // seems to indicate that 1/(4*FFTLength) is required. For the // moment I am baffled by this, although I guess has something do // to with multiplying in transformed space. double factor = this->m_Weight/(4*this->m_FFTLength); rampFilterGenerator.SetWeight(factor); rampFilterGenerator.ConstructRealSpaceFilter(rampFilterRealSpace); // performance check athabasca_assert(size_t(rampFilterRealSpace.ptr()) % 16 == 0); athabasca_assert(size_t(m_RampFilter->realp) % 16 == 0); bonelab::vDSP<TValue>::ctoz( reinterpret_cast<const TComplex*>(rampFilterRealSpace.ptr()), 2, this->m_RampFilter, 1, this->m_FFTLength/2); /* to the frequency domain */ bonelab::vDSP<TValue>::fft_zrip( this->m_FFTsetup, this->m_RampFilter, 1, this->m_PowerOfTwo, FFT_FORWARD); if (this->m_SmoothingFilter) { // Note: We will construct transferFunction out to this->m_FFTLength, // which is in fact more than we really need (for the storage // scheme used for symmetric real data). However, as the // length also indicates the Nyquist frequency, this is necessary // for correctness. TFunction1D transferFunction(this->m_FFTLength); this->m_SmoothingFilter->SetLength(this->m_FFTLength); this->m_SmoothingFilter->ConstructTransferFunction(transferFunction); // Multiply RampFilter by transferFunction, taking special care to deal with the // Nyquist component stored in imagp[0] in this storage scheme. TValue Nyquist_component = this->m_RampFilter->imagp[0] * transferFunction[this->m_FFTLength/2]; bonelab::vDSP<TValue>::vmul( this->m_RampFilter->realp, 1, transferFunction.ptr(), 1, this->m_RampFilter->realp, 1, this->m_FFTLength/2); this->m_RampFilter->imagp[0] = Nyquist_component; // Just assume that m_RampFilter has no imaginary part - actually even // if it does, it is ignored below. } }
void apply( void ) { m_ref_volume_renderer->setTransferFunction( transferFunction() ); m_ref_renderer->clearEnsembleBuffer(); screen()->redraw(); }