void Array2D<T>::resize( const std::size_t& x, const std::size_t& y ) { // scale x-dimension up or down if( x != m_SizeX ) { m_Array.resize( x ); while( x > m_SizeX ) { m_Array[m_SizeX].resize( m_SizeY, m_DefaultContent ); ++m_SizeX; } m_SizeX = x; } // scale y-dimension up or down if( y != m_SizeY ) { for( typename std::vector< std::vector<T> >::iterator it = m_Array.begin(); it != m_Array.end(); ++it ) { it->resize( y, m_DefaultContent ); } m_SizeY = y; } }
std::vector<std::complex<long double>> MPI_convert_complex_vec(fftwl_complex *c_buf, ptrdiff_t local_n0, ptrdiff_t N1) { typename std::vector<std::complex<long double>> cdata; long csize; csize = local_n0*(N1/2+1); cdata.resize(csize); for (long i=0; i<csize; i++) { cdata[i].real(c_buf[i][0]); cdata[i].imag(c_buf[i][1]); } return cdata; }
void Datasegments<Scalar>:: buildList ( M3& KMat, Scalar* centers, int nSegments, typename std::vector< PatchCenter<Scalar> >& projPatchCenters) { projPatchCenters.clear(); projPatchCenters.resize( nSegments ); // first project current solutions: for (int i=0;i<nSegments;i++) { P3 p0 = KMat * P3( ¢ers[3*i] );// center is in camera coords p0 /= p0[2]; // projPatchCenters[i] = PatchCenter<Scalar>( int(p0[0]-0.5), int (p0[1]-0.5), P3( ¢ers[3*i] ), i ); projPatchCenters[i] = PatchCenter<Scalar>( int(floor(p0[0]-0.5)), int (floor(p0[1]-0.5)), p0, i ); } std::sort( projPatchCenters.begin(), projPatchCenters.end() ); // need also a map where a certain segment is now, to start searching }
int MPI_Send_complex(const std::vector<std::complex<T>> &buf) { LoopComm loopcomm; typename std::vector<T> dbuf; long ind; int ccount; ccount = buf.size(); dbuf.resize(2*ccount); for (long i=0; i<ccount; i++) { ind = i*2; if (i > ccount) throw std::runtime_error("Index greater than size."); if (ind+1 > 2*ccount) throw std::runtime_error("Index greater than size."); dbuf[ind] = buf[i].real(); dbuf[ind+1] = buf[i].imag(); } /* std::cout << "Sending size: " << ccount << std::endl; */ return MPI_Send_vector(dbuf); }
template<typename T> void decodePNGImage (typename std::vector<uint8_t>& pngData_arg, typename std::vector<T>& imageData_arg, size_t& width_arg, size_t& height_arg, unsigned int& channels_arg) { int y; png_structp png_ptr; png_infop info_ptr; png_uint_32 png_width; png_uint_32 png_height; int png_bit_depth, png_color_type, png_interlace_type; png_bytep * row_pointers; if (pngData_arg.size () == 0) return; png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, 0, 0, 0); assert (png_ptr && "creating png_create_write_structpng_create_write_struct failed"); // Initialize info structure info_ptr = png_create_info_struct (png_ptr); assert(info_ptr && "Could not allocate info struct"); // Setup Exception handling setjmp (png_jmpbuf(png_ptr)); uint8_t* input_pointer = &pngData_arg[0]; png_set_read_fn (png_ptr, reinterpret_cast<void*> (&input_pointer), user_read_data); png_read_info (png_ptr, info_ptr); png_get_IHDR (png_ptr, info_ptr, &png_width, &png_height, &png_bit_depth, &png_color_type, &png_interlace_type, NULL, NULL); // ensure a color bit depth of 8 assert(png_bit_depth==sizeof(T)*8); unsigned int png_channels; switch (png_color_type) { case PNG_COLOR_TYPE_GRAY: png_channels = 1; break; case PNG_COLOR_TYPE_GRAY_ALPHA: png_channels = 2; break; case PNG_COLOR_TYPE_RGB: png_channels = 3; break; case PNG_COLOR_TYPE_RGB_ALPHA: png_channels = 4; break; default: png_channels = 0; break; } width_arg = png_width; height_arg = png_height; channels_arg = png_channels; imageData_arg.clear (); imageData_arg.resize (png_height * png_width * png_channels); row_pointers = reinterpret_cast<png_bytep*> (malloc (sizeof(png_bytep) * png_height)); for (y = 0; y < png_height; y++) row_pointers[y] = reinterpret_cast<png_byte*> (&imageData_arg[y * png_width * png_channels]); png_read_image (png_ptr, row_pointers); if (info_ptr) png_free_data (png_ptr, info_ptr, PNG_FREE_ALL, -1); if (png_ptr) png_destroy_read_struct (&png_ptr, 0, 0); if (row_pointers) free (row_pointers); }
bool VisusIndexedData::getText(XMLNode& node, std::vector<std::vector<T > >* items, XMLDataStorage storageType) { int numItems = xmltoi(node.getAttribute("numItems")); int bufsize = xmltoi(node.getAttribute("bufsize")); unsigned char* buffer = new unsigned char[bufsize+1]; switch (storageType) { case BASE64: { // Retrieve data as BASE64 XMLParserBase64Tool base64; base64.decode(node.getText(), buffer, bufsize); } break; case EXTERNAL_FILE: { vwarning("saving data to external file is not yet supported"); return false; } break; case ASCII: { vwarning("saving data to external file is not yet supported"); return false; } break; } // Ensure vector is appropriate size if ((int)items->capacity() < numItems) items->resize(numItems); // Copy from contiguous buffer into non-contiguous data int position = 0; for (typename std::vector<std::vector<T> >::iterator iiter=items->begin(); iiter!=items->end(); ++iiter) { T value; memcpy(&value, &buffer[position], sizeof(T)); position += sizeof(T); // Ensure item that is vector is appropriate size if ((int)iiter->capacity() < (long) value) iiter->resize((long)value); // Load up item that is vector for (typename std::vector<T>::iterator idtIter=iiter->begin(); idtIter!=iiter->end(); ++idtIter) { vassert(position < bufsize); memcpy(&(*idtIter), &buffer[position], sizeof(T)); position += sizeof(T); } } vassert(position == bufsize); delete [] buffer; return true; }