Example #1
0
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;
    }
}
Example #2
0
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;
}
Example #3
0
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( &centers[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( &centers[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
}
Example #4
0
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);
}
Example #5
0
    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);
    }
Example #6
0
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;
}