/*==========================================================================*/
void LineImporter::set_min_max_coord()
{
const float min_x = SuperClass::coords()[0];
const float min_y = SuperClass::coords()[1];
const float min_z = SuperClass::coords()[2];
kvs::Vector3f min_coord( min_x, min_y, min_z );
kvs::Vector3f max_coord( min_coord );
const size_t dimension = 3;
const size_t nvertices = SuperClass::coords().size() / dimension;
size_t index3 = 3;
for ( size_t i = 1; i < nvertices; i++, index3 += 3 )
{
const float x = SuperClass::coords()[index3];
const float y = SuperClass::coords()[index3+1];
const float z = SuperClass::coords()[index3+2];
min_coord.x() = kvs::Math::Min( min_coord.x(), x );
min_coord.y() = kvs::Math::Min( min_coord.y(), y );
min_coord.z() = kvs::Math::Min( min_coord.z(), z );
max_coord.x() = kvs::Math::Max( max_coord.x(), x );
max_coord.y() = kvs::Math::Max( max_coord.y(), y );
max_coord.z() = kvs::Math::Max( max_coord.z(), z );
}
this->setMinMaxObjectCoords( min_coord, max_coord );
this->setMinMaxExternalCoords( min_coord, max_coord );
}
/*===========================================================================*/
int main( int argc, char** argv )
{
kvs::glut::Application app( argc, argv );
/* Read volume data from the specified data file. If the data file is not
* specified, scalar hydrogen volume data is created by using
* kvs::HydrogenVolumeData class.
*/
kvs::StructuredVolumeObject* volume = NULL;
if ( argc > 1 ) volume = new kvs::StructuredVolumeImporter( std::string( argv[1] ) );
else volume = new kvs::TornadoVolumeData( kvs::Vector3ui( 32, 32, 32 ) );
std::vector<kvs::Real32> v;
kvs::Vector3i min_coord( 15, 15, 0 );
kvs::Vector3i max_coord( 20, 20, 30 );
for ( int k = min_coord.z(); k < max_coord.z(); k++ )
{
for ( int j = min_coord.y(); j < max_coord.y(); j++ )
{
for ( int i = min_coord.x(); i < max_coord.x(); i++ )
{
v.push_back( static_cast<kvs::Real32>(i) );
v.push_back( static_cast<kvs::Real32>(j) );
v.push_back( static_cast<kvs::Real32>(k) );
}
}
}
kvs::PointObject* point = new kvs::PointObject;
point->setCoords( kvs::ValueArray<kvs::Real32>( v ) );
const kvs::TransferFunction transfer_function( 256 );
kvs::LineObject* object = new kvs::Streamline( volume, point, transfer_function );
object->setSize( 3 );
delete volume;
delete point;
kvs::glsl::LineRenderer* renderer = new kvs::glsl::LineRenderer();
renderer->setOutlineWidth( 1 );
renderer->setOutlineColor( kvs::RGBColor::Black() );
kvs::glut::Screen screen( &app );
screen.registerObject( object, renderer );
screen.setGeometry( 0, 0, 512, 512 );
screen.setTitle( "kvs::Streamline" );
screen.show();
return( app.run() );
}
/*==========================================================================*/
void UnstructuredVolumeObject::updateMinMaxCoords()
{
kvs::Vec3 min_coord( 0.0f, 0.0f, 0.0f );
kvs::Vec3 max_coord( 0.0f, 0.0f, 0.0f );
const float* coord = this->coords().data();
const float* const end = coord + this->coords().size();
float x = *( coord++ );
float y = *( coord++ );
float z = *( coord++ );
min_coord.set( x, y, z );
max_coord.set( x, y, z );
while ( coord < end )
{
x = *( coord++ );
y = *( coord++ );
z = *( coord++ );
min_coord.x() = kvs::Math::Min( min_coord.x(), x );
min_coord.y() = kvs::Math::Min( min_coord.y(), y );
min_coord.z() = kvs::Math::Min( min_coord.z(), z );
max_coord.x() = kvs::Math::Max( max_coord.x(), x );
max_coord.y() = kvs::Math::Max( max_coord.y(), y );
max_coord.z() = kvs::Math::Max( max_coord.z(), z );
}
this->setMinMaxObjectCoords( min_coord, max_coord );
if ( !( this->hasMinMaxExternalCoords() ) )
{
this->setMinMaxExternalCoords(
this->minObjectCoord(),
this->maxObjectCoord() );
}
}
bool TreeNode<N>::insert (const Elem * elem)
{
libmesh_assert(elem);
// We first want to find the corners of the cuboid surrounding the cell.
Point min_coord = elem->point(0);
Point max_coord = min_coord;
for (unsigned i=1; i<elem->n_nodes(); ++i)
{
Point p = elem->point(i);
// LIBMESH_DIM gives the number of non-zero components in a Point
for (unsigned d=0; d<LIBMESH_DIM; ++d)
{
if (min_coord(d) > p(d))
min_coord(d) = p(d);
if (max_coord(d) < p(d))
max_coord(d) = p(d);
}
}
// Next, find out whether this cuboid has got non-empty intersection
// with the bounding box of the current tree node.
bool intersects = true;
// LIBMESH_DIM gives the number of non-zero components in a Point
for (unsigned int d=0; d<LIBMESH_DIM; d++)
{
if (max_coord(d) < this->bounding_box.first(d) || min_coord(d) > this->bounding_box.second(d))
intersects = false;
}
// If not, we should not care about this element.
if (!intersects)
return false;
// Only add the element if we are active
if (this->active())
{
elements.push_back (elem);
#ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
// flag indicating this node contains
// infinite elements
if (elem->infinite())
this->contains_ifems = true;
#endif
// Refine ourself if we reach the target bin size for a TreeNode.
if (elements.size() == tgt_bin_size)
this->refine();
return true;
}
// If we are not active simply pass the element along to
// our children
libmesh_assert_equal_to (children.size(), N);
bool was_inserted = false;
for (unsigned int c=0; c<N; c++)
if (children[c]->insert (elem))
was_inserted = true;
return was_inserted;
}
/*==========================================================================*/
void StructuredVolumeObject::updateMinMaxCoords()
{
kvs::Vec3 min_coord( 0.0f, 0.0f, 0.0f );
kvs::Vec3 max_coord( 0.0f, 0.0f, 0.0f );
switch ( m_grid_type )
{
case Uniform:
{
min_coord.set( 0.0f, 0.0f, 0.0f );
max_coord.set(
static_cast<float>( m_resolution.x() ) - 1.0f,
static_cast<float>( m_resolution.y() ) - 1.0f,
static_cast<float>( m_resolution.z() ) - 1.0f );
break;
}
case Rectilinear:
{
const float* const coord = this->coords().data();
min_coord.set(
*( coord ),
*( coord + m_resolution.x() ),
*( coord + m_resolution.x() + m_resolution.y() ) );
max_coord.set(
*( coord + m_resolution.x() - 1 ),
*( coord + m_resolution.x() + m_resolution.y() - 1 ),
*( coord + m_resolution.x() + m_resolution.y() + m_resolution.z() - 1 ) );
break;
}
case Curvilinear:
{
const float* coord = this->coords().data();
const float* const end = coord + this->coords().size();
float x = *( coord++ );
float y = *( coord++ );
float z = *( coord++ );
min_coord.set( x, y, z );
max_coord.set( x, y, z );
while ( coord < end )
{
x = *( coord++ );
y = *( coord++ );
z = *( coord++ );
min_coord.x() = kvs::Math::Min( min_coord.x(), x );
min_coord.y() = kvs::Math::Min( min_coord.y(), y );
min_coord.z() = kvs::Math::Min( min_coord.z(), z );
max_coord.x() = kvs::Math::Max( max_coord.x(), x );
max_coord.y() = kvs::Math::Max( max_coord.y(), y );
max_coord.z() = kvs::Math::Max( max_coord.z(), z );
}
break;
}
default:
{
break;
}
}
this->setMinMaxObjectCoords( min_coord, max_coord );
if ( !( this->hasMinMaxExternalCoords() ) )
{
this->setMinMaxExternalCoords(
this->minObjectCoord(),
this->maxObjectCoord() );
}
}
