Пример #1
0
std::vector<float> VoxeledModel::genNormals() 
{

	std::vector<float> v; 

	for (int i = 0; i<m_array.getSizeX(); i++) 
	{
		for (int j = 0; j<m_array.getSizeY(); j++) 
		{
			for (int k = 0; k<m_array.getSizeZ(); k++) 
			{
				if (m_array(i,j,k)) 
				{
					Vector n = voxelNormal(i,j,k).normalized();
					v.push_back(n.getX()); v.push_back(n.getY()); v.push_back(n.getZ());
					v.push_back(n.getX()); v.push_back(n.getY()); v.push_back(n.getZ());
					v.push_back(n.getX()); v.push_back(n.getY()); v.push_back(n.getZ());
					v.push_back(n.getX()); v.push_back(n.getY()); v.push_back(n.getZ());
					v.push_back(n.getX()); v.push_back(n.getY()); v.push_back(n.getZ());
					v.push_back(n.getX()); v.push_back(n.getY()); v.push_back(n.getZ());
					v.push_back(n.getX()); v.push_back(n.getY()); v.push_back(n.getZ());
					v.push_back(n.getX()); v.push_back(n.getY()); v.push_back(n.getZ());
				}
			}
		}
	}
	return v; 

}
Пример #2
0
std::vector<float> VoxeledModel::genVertexColors() 
{
	std::vector<float> v; 

	for (int i = 0; i<m_array.getSizeX(); i++) 
	{
		for (int j = 0; j<m_array.getSizeY(); j++) 
		{
			for (int k = 0; k<m_array.getSizeZ(); k++) 
			{
				if (m_array(i,j,k)) 
				{
					Color c = voxelColor(i,j,k);
					v.push_back(c.red); v.push_back(c.green); v.push_back(c.blue); v.push_back(c.alpha);
					v.push_back(c.red); v.push_back(c.green); v.push_back(c.blue); v.push_back(c.alpha);
					v.push_back(c.red); v.push_back(c.green); v.push_back(c.blue); v.push_back(c.alpha);
					v.push_back(c.red); v.push_back(c.green); v.push_back(c.blue); v.push_back(c.alpha);
					v.push_back(c.red); v.push_back(c.green); v.push_back(c.blue); v.push_back(c.alpha);
					v.push_back(c.red); v.push_back(c.green); v.push_back(c.blue); v.push_back(c.alpha);
					v.push_back(c.red); v.push_back(c.green); v.push_back(c.blue); v.push_back(c.alpha);
					v.push_back(c.red); v.push_back(c.green); v.push_back(c.blue); v.push_back(c.alpha);
				}
			}
		}
	}
	return v; 

}
Пример #3
0
std::vector<float> VoxeledModel::genTextureCoordinates() 
{

	std::vector<float> a;

	for (int i = 0; i<m_array.getSizeX(); i++) 
	{
		for (int j = 0; j<m_array.getSizeY(); j++) 
		{
			for (int k = 0; k<m_array.getSizeZ(); k++) 
			{
				if (m_array(i,j,k)) 
				{
					float u,v,u1,v1, x,y,x1,y1;
					std::tie (u,v,u1,v1,x,y,x1,y1) = voxelTextureCoordinates(i,j,k);
					a.push_back(u); a.push_back(v);
					a.push_back(u1); a.push_back(v);
					a.push_back(u1); a.push_back(v1);
					a.push_back(u); a.push_back(v1);
					
					a.push_back(x); a.push_back(y);
					a.push_back(x1); a.push_back(y);
					a.push_back(x1); a.push_back(y1);
					a.push_back(x); a.push_back(y1);
				}
			}
		}
	}
	return a;
}
Пример #4
0
  KOKKOS_INLINE_FUNCTION
  void operator()( size_type global_i , value_type & errors ) const
  {
    typedef typename array_type::tile_type tile_type;

    size_t t0 = m_array.global_to_tile_index_0(global_i);
    size_t i = m_array.global_to_local_tile_index_0(global_i);

    for (size_t global_j = 0, dim_1 = m_array.dimension_1(); global_j < dim_1; ++global_j) {

      ptrdiff_t offset = &m_array(global_i,global_j) - &m_array(0,0);

      size_t t1 = m_array.global_to_tile_index_1(global_j);
      size_t j = m_array.global_to_local_tile_index_1(global_j);

      // tile_type tile = m_array.tile(t0,t1);

      tile_type tile = Kokkos::subview< tile_type >( m_array , t0 , t1 );

      tile(i,j) = (tile.dimension_0() * tile.dimension_1()) * (t0 + m_array.tiles_in_dimension_0() * t1) + i + (j * tile.dimension_0());

      errors += (offset != m_array(global_i,global_j));
    }
  }
Пример #5
0
std::vector<float> VoxeledModel::genVertices() 
{
	std::vector<float> v; 

	// compute steps 
	float sx,sy,sz; 
	sx = 2.0 / m_array.getSizeX(); 
	sy = 2.0 / m_array.getSizeY();
	sz = 2.0 / m_array.getSizeZ();
	for (int i = 0; i<m_array.getSizeX(); i++) 
	{
		for (int j = 0; j<m_array.getSizeY(); j++) 
		{
			for (int k = 0; k<m_array.getSizeZ(); k++) 
			{
				if (m_array(i,j,k)) 
				{
					float x,y,z; 
					x = -1 + sx*i; 
					y = -1 + sy*j; 
					z = -1 + sz*k;
					// we are adding 8 vertices 

					v.push_back(x); v.push_back(y); v.push_back(z);
					v.push_back(x+sx); v.push_back(y); v.push_back(z);
					v.push_back(x+sx); v.push_back(y); v.push_back(z+sz);
					v.push_back(x); v.push_back(y); v.push_back(z+sz);

					v.push_back(x); v.push_back(y+sy); v.push_back(z);
					v.push_back(x+sx); v.push_back(y+sy); v.push_back(z);
					v.push_back(x+sx); v.push_back(y+sy); v.push_back(z+sz);
					v.push_back(x); v.push_back(y+sy); v.push_back(z+sz);
				}
			}
		}
	}
	return v; 
}
Пример #6
0
std::vector<int> VoxeledModel::genIndices() 
{
	std::vector<int> v; 
	int start = 0;
	for (int i = 0; i<m_array.getSizeX(); i++) 
	{
		for (int j = 0; j<m_array.getSizeY(); j++) 
		{
			for (int k = 0; k<m_array.getSizeZ(); k++) 
			{
				if (m_array(i,j,k)) 
				{
					v.push_back(8*start + 0); v.push_back(8*start + 1); v.push_back(8*start + 2);
					v.push_back(8*start + 0); v.push_back(8*start + 3); v.push_back(8*start + 2);
					
					v.push_back(8*start + 0); v.push_back(8*start + 3); v.push_back(8*start + 4);
					v.push_back(8*start + 3); v.push_back(8*start + 4); v.push_back(8*start + 7);

					v.push_back(8*start + 1); v.push_back(8*start + 2); v.push_back(8*start + 5);
					v.push_back(8*start + 2); v.push_back(8*start + 5); v.push_back(8*start + 6);

					v.push_back(8*start + 0); v.push_back(8*start + 1); v.push_back(8*start + 5);
					v.push_back(8*start + 0); v.push_back(8*start + 4); v.push_back(8*start + 5);
					
					v.push_back(8*start + 2); v.push_back(8*start + 3); v.push_back(8*start + 6);
					v.push_back(8*start + 3); v.push_back(8*start + 6); v.push_back(8*start + 7);

					v.push_back(8*start + 4); v.push_back(8*start + 5); v.push_back(8*start + 6);
					v.push_back(8*start + 4); v.push_back(8*start + 6); v.push_back(8*start + 7);

					start++;
				}
			}
		}
	}
	return v; 

}
Пример #7
0
inline const T &_1dSliceOfConst4dArray<T>::operator()(size_t index0) const {
  return m_array(index0, m_index1, m_index2, m_index3);
}
Пример #8
0
inline T &_1dSliceOf4dArray<T>::operator()(size_t index0) {
  return m_array(index0, m_index1, m_index2, m_index3);
}
Пример #9
0
inline const T &_2dSliceOf4dArray<T>::operator()(size_t index0,
                                                 size_t index1) const {
  return m_array(index0, index1, m_index2, m_index3);
}
Пример #10
0
inline T &_2dSliceOf3dArray<T>::operator()(size_t index0, size_t index1) {
  return m_array(index0, index1, m_index2);
}