/********************************************//** \brief Compute Inverse Fast Wavelet Transform (iFWT) on 1D array \param array : input array (1D) \param filter : name of the filter to use (from TransformationType enum) \param origLength : original length of the array so the result is cut at this length \param result : resulting transformed array \param stop : flag indicating if we need to stop the process or not \return boolean true if the execution is finished, false if the process has been stopped during the execution ***********************************************/ bool FWT::iFastWaveletTransf(const std::vector<float>& array, const TransformationType filter, const int origLength, std::vector<float>& result, bool* stop) { // Get filters std::deque<float> h, g; compute_wavelet_filters(filter, h, g); // Reverse filters std::deque<float> hRev = h; std::reverse(hRev.begin(), hRev.end()); std::deque<float> gRev = g; std::reverse(gRev.begin(), gRev.end()); std::vector<float> inv(array.begin(), array.end()); // iFWT int Jmax = log2((float)inv.size()) - 1; int Jmin = 0; for(int j = Jmin; j <= Jmax; ++j) { if(*stop) { return false; } std::vector<float> Coarse(&inv[0], &inv[pow(2., j)]); std::vector<float> Detail(&inv[pow(2., j)], &inv[pow(2.,j+1)]); // Get Coarse and Detail Coarse = cconv(upsampling(Coarse), hRev); Detail = cconv(upsampling(Detail), gRev); for(int k = 0; k < pow(2., j+1); ++k) { if(*stop) { return false; } inv[k] = Coarse[k] + Detail[k]; } } // Remove points so result is origLength length int N = pow(2, ceil(log2((float)origLength))) - origLength; removePoints(inv, N); result = inv; return true; }
void ccv_sample_up(ccv_dense_matrix_t* a, ccv_dense_matrix_t** b, int type, int src_x, int src_y) { assert(src_x >= 0 && src_y >= 0); ccv_declare_matrix_signature(sig, a->sig != 0, ccv_sign_with_format(64, "ccv_sample_up(%d,%d)", src_x, src_y), a->sig, 0); type = (type == 0) ? CCV_GET_DATA_TYPE(a->type) | CCV_GET_CHANNEL(a->type) : CCV_GET_DATA_TYPE(type) | CCV_GET_CHANNEL(a->type); ccv_dense_matrix_t* db = *b = ccv_dense_matrix_renew(*b, a->rows * 2, a->cols * 2, CCV_ALL_DATA_TYPE | CCV_GET_CHANNEL(a->type), type, sig); ccv_matrix_return_if_cached(, db); int ch = CCV_GET_CHANNEL(a->type); int cols0 = a->cols - 1 - src_x; int y, x, sy = -1 + src_y, sx = src_x * ch, k; int* tab = (int*)alloca((a->cols + src_x + 2) * ch * sizeof(int)); for (x = 0; x < a->cols + src_x + 2; x++) for (k = 0; k < ch; k++) tab[x * ch + k] = ((x >= a->cols) ? a->cols * 2 - 1 - x : x) * ch + k; unsigned char* buf = (unsigned char*)alloca(3 * db->cols * ch * ccv_max(CCV_GET_DATA_TYPE_SIZE(db->type), sizeof(int))); int bufstep = db->cols * ch * ccv_max(CCV_GET_DATA_TYPE_SIZE(db->type), sizeof(int)); unsigned char* b_ptr = db->data.u8; /* why src_y * 2: the same argument as in ccv_sample_down */ #define for_block(_for_get_a, _for_set, _for_get, _for_set_b) \ for (y = 0; y < a->rows; y++) \ { \ for (; sy <= y + 1 + src_y; sy++) \ { \ unsigned char* row = buf + ((sy + src_y * 2 + 1) % 3) * bufstep; \ int _sy = (sy < 0) ? -1 - sy : (sy >= a->rows) ? a->rows * 2 - 1 - sy : sy; \ unsigned char* a_ptr = a->data.u8 + a->step * _sy; \ if (a->cols == 1) \ { \ for (k = 0; k < ch; k++) \ { \ _for_set(row, k, _for_get_a(a_ptr, k, 0) * (G025 + G075 + G125), 0); \ _for_set(row, k + ch, _for_get_a(a_ptr, k, 0) * (G025 + G075 + G125), 0); \ } \ continue; \ } \ if (sx == 0) \ { \ for (k = 0; k < ch; k++) \ { \ _for_set(row, k, _for_get_a(a_ptr, k + sx, 0) * (G025 + G075) + _for_get_a(a_ptr, k + sx + ch, 0) * G125, 0); \ _for_set(row, k + ch, _for_get_a(a_ptr, k + sx, 0) * (G125 + G025) + _for_get_a(a_ptr, k + sx + ch, 0) * G075, 0); \ } \ } \ /* some serious flaw in computing Gaussian weighting in previous version * specially, we are doing perfect upsampling (2x) so, it concerns a grid like: * XXYY * XXYY * in this case, to upsampling, the weight should be from distance 0.25 and 1.25, and 0.25 and 0.75 * previously, it was mistakingly be 0.0 1.0, 0.5 0.5 (imperfect upsampling (2x - 1)) */ \ for (x = (sx == 0) ? ch : 0; x < cols0 * ch; x += ch) \ { \ for (k = 0; k < ch; k++) \ { \ _for_set(row, x * 2 + k, _for_get_a(a_ptr, x + sx - ch + k, 0) * G075 + _for_get_a(a_ptr, x + sx + k, 0) * G025 + _for_get_a(a_ptr, x + sx + ch + k, 0) * G125, 0); \ _for_set(row, x * 2 + ch + k, _for_get_a(a_ptr, x + sx - ch + k, 0) * G125 + _for_get_a(a_ptr, x + sx + k, 0) * G025 + _for_get_a(a_ptr, x + sx + ch + k, 0) * G075, 0); \ } \ } \ x_block(_for_get_a, _for_set, _for_get, _for_set_b); \ } \