const kvs::Vector3f DepthGenerator::realPosition( const kvs::Vector3f& pos )
{
if ( !m_is_created )
{
kvsMessageError( "DepthGenerator is not created yet." );
return( pos );
}
XnPoint3D proj;
XnPoint3D real;
proj.X = pos.x();
proj.Y = pos.y();
proj.Z = pos.z();
XnStatus status = m_generator.ConvertProjectiveToRealWorld( 1, &proj, &real );
if ( status != XN_STATUS_OK )
{
kvsMessageError( "%s error: <%s>.",
xnGetStatusName( status ),
xnGetStatusString( status ) );
return( pos );
}
return( kvs::Vector3f( real.X, real.Y, real.Z ) );
}
void ColonLED::create_coords( const kvs::Vector3f& center )
{
m_coords.allocate( 3 * 8 );
const float length = 2.0;
const float width = 0.2;
// Set const z coord.
for ( size_t i = 2; i < 24; i += 3 ) m_coords[i] = center.z();
for ( size_t i = 0; i < 2; i++ )
{
float is_minus = ( i == 0 ) ? 1.0f : - 1.0f;
m_coords[ i * 12 + 0 ] = center.x() - width;
m_coords[ i * 12 + 1 ] = center.y() + is_minus * length / 2 + width;
m_coords[ i * 12 + 3 ] = center.x() + width;
m_coords[ i * 12 + 4 ] = center.y() + is_minus * length / 2 + width;
m_coords[ i * 12 + 6 ] = center.x() + width;
m_coords[ i * 12 + 7 ] = center.y() + is_minus * length / 2 - width;
m_coords[ i * 12 + 9 ] = center.x() - width;
m_coords[ i * 12 + 10 ] = center.y() + is_minus * length / 2 - width;
}
}
const kvs::Vector3f ScreenController::vertex_of_joint(
const unsigned int index,
const kvs::ni::Skeleton::SkeletonJoint& joint,
kvs::ni::DepthGenerator& depth,
kvs::ni::UserGenerator& user )
{
const kvs::ni::JointPosition pos = user.skeleton().jointPosition( index, joint );
const kvs::Vector3f proj_pos = depth.projectPosition( pos.position() );
const float d = 0.001f * proj_pos.z();
return( kvs::Vector3f(
d * m_p2r * ( proj_pos.x() - m_cx ),
d * m_p2r * ( float( m_height ) - proj_pos.y() - m_cy ),
- d ) );
}
/*===========================================================================*/
void ExtractEdges::calculate_uniform_coords( const kvs::StructuredVolumeObject* volume )
{
kvs::ValueArray<kvs::Real32> coords( 3 * volume->numberOfNodes() );
kvs::Real32* coord = coords.data();
const kvs::Vector3ui resolution( volume->resolution() );
const kvs::Vector3f volume_size( volume->maxObjectCoord() - volume->minObjectCoord() );
const kvs::Vector3ui ngrids( resolution - kvs::Vector3ui( 1, 1, 1 ) );
const kvs::Vector3f grid_size(
volume_size.x() / static_cast<float>( ngrids.x() ),
volume_size.y() / static_cast<float>( ngrids.y() ),
volume_size.z() / static_cast<float>( ngrids.z() ) );
for ( size_t k = 0; k < resolution.z(); ++k )
{
const float z =
grid_size.z() * static_cast<float>( k );
for ( size_t j = 0; j < resolution.y(); ++j )
{
const float y =
grid_size.y() * static_cast<float>( j );
for ( size_t i = 0; i < resolution.x(); ++i )
{
const float x =
grid_size.x() * static_cast<float>( i );
*( coord++ ) = x;
*( coord++ ) = y;
*( coord++ ) = z;
}
}
}
SuperClass::setCoords( coords );
}
void Ply::calculate_normals()
{
kvs::ValueArray<kvs::UInt32> counter( m_nverts );
counter.fill( 0 );
m_normals.allocate( m_nverts * 3 );
const kvs::UInt32* pconnections = m_connections.data();
const kvs::Real32* pcoords = m_coords.data();
for ( size_t i = 0; i < m_nfaces; i++ )
{
// Calculate normal vector for each triangles.
const kvs::UInt32 index0 = *(pconnections++);
const kvs::UInt32 index1 = *(pconnections++);
const kvs::UInt32 index2 = *(pconnections++);
const kvs::Vector3f v0( pcoords + 3 * index0 );
const kvs::Vector3f v1( pcoords + 3 * index1 );
const kvs::Vector3f v2( pcoords + 3 * index2 );
const kvs::Vector3f normal = ( ( v1 - v0 ).cross( v2 - v1 ) ).normalized();
// Sum of the normal vectors of the adjacent triangles for the vertex.
m_normals[ 3 * index0 + 0 ] = normal.x();
m_normals[ 3 * index0 + 1 ] = normal.y();
m_normals[ 3 * index0 + 2 ] = normal.z();
counter[ index0 ] += 1;
m_normals[ 3 * index1 + 0 ] = normal.x();
m_normals[ 3 * index1 + 1 ] = normal.y();
m_normals[ 3 * index1 + 2 ] = normal.z();
counter[ index1 ] += 1;
m_normals[ 3 * index2 + 0 ] = normal.x();
m_normals[ 3 * index2 + 1 ] = normal.y();
m_normals[ 3 * index2 + 2 ] = normal.z();
counter[ index2 ] += 1;
}
for ( size_t i = 0; i < m_nverts; i++ )
{
if ( counter[i] == 0 ) continue;
m_normals[ 3 * i + 0 ] /= static_cast<kvs::Real32>( counter[i] );
m_normals[ 3 * i + 1 ] /= static_cast<kvs::Real32>( counter[i] );
m_normals[ 3 * i + 2 ] /= static_cast<kvs::Real32>( counter[i] );
}
}
/*===========================================================================*/
const kvs::RGBColor Shader::Phong::shadedColor(
const kvs::RGBColor& color,
const kvs::Vector3f& vertex,
const kvs::Vector3f& normal ) const
{
// Light vector L, normal vector N and reflection vector R.
const kvs::Vector3f V = ( camera_position - vertex ).normalized();
const kvs::Vector3f L = ( light_position - vertex ).normalized();
const kvs::Vector3f N = normal.normalized();
const kvs::Vector3f R = 2.0f * N.dot( L ) * N - L;
// Intensity values.
const float Ia = kvsShaderAmbientTerm( Ka );
const float Id = kvsShaderDiffuseTerm( Kd, N, L );
const float Is = kvsShaderSpecularTerm( ks, S, R, V );
return ::Shade( color, Ia, Id, Is );
}
void OneSegment::build_segment_coord(
const kvs::Vector3f& center,
const float length,
const float width,
const float offset,
const float left_ratio,
const float right_ratio,
const float rotate_theta )
{
m_coords.allocate( 3 * 6 );
// Set const z coord.
for ( size_t i = 2; i < 18; i += 3 ) m_coords[i] = center.z();
const float half_length = length / 2;
m_coords[ 0] = - ( half_length + left_ratio * width - offset );
m_coords[ 1] = - left_ratio * width;
m_coords[ 3] = - ( half_length - width - offset );
m_coords[ 4] = width;
m_coords[ 6] = - ( half_length - ( 1.0f - 2 * left_ratio ) * width - offset );
m_coords[ 7] = - width;
m_coords[ 9] = ( half_length - width - offset );
m_coords[10] = width;
m_coords[12] = ( half_length - ( 1.0f - 2 * right_ratio ) * width - offset );
m_coords[13] = - width;
m_coords[15] = ( half_length + right_ratio * width - offset );
m_coords[16] = - right_ratio * width;
for ( size_t i = 0; i < 6; i++ )
{
const float theta = kvs::Math::Deg2Rad( rotate_theta );
const float x = m_coords[ i * 3 + 0 ];
const float y = m_coords[ i * 3 + 1 ];
m_coords[ i * 3 + 0 ] = center.x() + cosf( theta ) * x + sinf( theta ) * y;
m_coords[ i * 3 + 1 ] = center.y() - sinf( theta ) * x + cosf( theta ) * y;
}
}
/*===========================================================================*/
void PolygonToPolygon::calculate_triangle_normals( void )
{
const size_t nvertices = SuperClass::nvertices();
const size_t npolygons = SuperClass::nconnections();
const float* p_coords = SuperClass::coords().pointer();
const unsigned int* p_connections = SuperClass::connections().pointer();
kvs::ValueArray<float> normals( 3 * nvertices );
normals.fill( 0x00 );
for ( size_t i = 0; i < npolygons; i++ )
{
size_t index[3];
kvs::Vector3f vertex[3];
for ( size_t j = 0; j < 3; j++ )
{
index[j] = p_connections[ 3 * i + j ];
vertex[j] = kvs::Vector3f( p_coords + 3 * index[j] );
}
const kvs::Vector3f normal( ( vertex[1] - vertex[0] ).cross( vertex[2] - vertex[0] ) );
for ( size_t j = 0; j < 3; j++ )
{
normals[ 3 * index[j] ] += normal.x();
normals[ 3 * index[j] + 1 ] += normal.y();
normals[ 3 * index[j] + 2 ] += normal.z();
}
}
// Normalize normals.
const float* p_normals = normals.pointer();
for ( size_t i = 0; i < nvertices; i++ )
{
kvs::Vector3f normal( p_normals + i * 3 );
normal.normalize();
normals[ i * 3 ] = normal.x();
normals[ i * 3 + 1 ] = normal.y();
normals[ i * 3 + 2 ] = normal.z();
}
SuperClass::setNormals( normals );
SuperClass::setNormalType( kvs::PolygonObject::VertexNormal );
}
/*==========================================================================*/
inline float Shader::Phong::attenuation( const kvs::Vector3f& vertex, const kvs::Vector3f& gradient ) const
{
// Light vector L, normal vector N and reflection vector R.
const kvs::Vector3f L = ( light_position - vertex ).normalized();
const kvs::Vector3f N = gradient.normalized();
const kvs::Vector3f R = 2.0f * N.dot( L ) * N - L;
const float dd = Math::Max( N.dot( L ), 0.0f );
const float ds = Math::Max( N.dot( R ), 0.0f );
/* I = Ia + Id + Is
*
* Is = Ip * Ks * cos^s(B) = Ip * Ks * ( R dot N )^s
*/
const float Ia = Ka;
const float Id = Kd * dd;
const float Is = Ks * std::pow( ds, S );
return Ia + Id + Is;
}
/*==========================================================================*/
inline float Shader::Lambert::attenuation( const kvs::Vector3f& vertex, const kvs::Vector3f& gradient ) const
{
// Light vector L and normal vector N.
const kvs::Vector3f L = ( light_position - vertex ).normalized();
const kvs::Vector3f N = gradient.normalized();
const float dd = kvs::Math::Max( N.dot( L ), 0.0f );
/* I = Ia + Id
*
* Ia = Ka (constant term)
* Id = Ip * Kd * cos(A) = Ip * Kd * ( L dot N )
*
* Ip : the intensity emitted from the light source.
*/
const float Ia = Ka;
const float Id = Kd * dd;
return Ia + Id;
}
/*==========================================================================*/
inline float Shader::BlinnPhong::attenuation( const kvs::Vector3f& vertex, const kvs::Vector3f& gradient ) const
{
// Camera vector C, light vector L, halfway vector H and normal vector N.
const kvs::Vector3f C = ( camera_position - vertex ).normalized();
const kvs::Vector3f L = ( light_position - vertex ).normalized();
const kvs::Vector3f H = ( C + L ).normalized();
const kvs::Vector3f N = gradient.normalized();
const float dd = kvs::Math::Max( N.dot( L ), 0.0f );
const float ds = kvs::Math::Max( N.dot( H ), 0.0f );
/* I = Ia + Id + Is
*
* Is = Ip * Ks * cos^s(B) = Ip * Ks * ( H dot N )^s
*/
const float Ia = Ka;
const float Id = Kd * dd;
const float Is = Ks * ::pow( ds, S );
return Ia + Id + Is;
}
const bool HandsGenerator::startTracking( const kvs::Vector3f& position )
{
if ( !m_is_created )
{
kvsMessageError( "HandsGenerator is not created yet." );
return( false );
}
XnPoint3D pos;
pos.X = position.x();
pos.Y = position.y();
pos.Z = position.z();
XnStatus status = m_generator.StartTracking( pos );
if ( status != XN_STATUS_OK )
{
kvsMessageError( "%s error: <%s>.",
xnGetStatusName( status ),
xnGetStatusString( status ) );
return( false );
}
return( true );
}
/*===========================================================================*/
const kvs::RGBColor Shader::Lambert::shadedColor(
const kvs::RGBColor& color,
const kvs::Vector3f& vertex,
const kvs::Vector3f& normal ) const
{
// Light vector L and normal vector N.
const kvs::Vector3f L = ( light_position - vertex ).normalized();
const kvs::Vector3f N = normal.normalized();
// Intensity values.
const float Ia = kvsShaderAmbientTerm( Ka );
const float Id = kvsShaderDiffuseTerm( Kd, N, L );
return color * ( Ia + Id );
}
void sliderMoved( void )
{
const float dz_new = this->value();
const float _zmin = center.z() - dz_new / 2;
const float _zmax = center.z() + dz_new / 2;
m_seed_point->setZMin( _zmin );
m_seed_point->setZMax( _zmax );
m_seed_point->reset_coordinates();
#ifdef USE_KVS
m_compositor->changeObject( m_seed_point, m_seed_point, false );
#else
m_renderer->changeObject( m_seed_point, m_point_renderer, false );
#endif
}
/*===========================================================================*/
const kvs::RGBColor Shader::BlinnPhong::shadedColor(
const kvs::RGBColor& color,
const kvs::Vector3f& vertex,
const kvs::Vector3f& normal ) const
{
// Camera vector V, light vector L, halfway vector H and normal vector N.
const kvs::Vector3f V = ( camera_position - vertex ).normalized();
const kvs::Vector3f L = ( light_position - vertex ).normalized();
const kvs::Vector3f H = ( V + L ).normalized();
const kvs::Vector3f N = normal.normalized();
// Intensity values.
const float Ia = kvsShaderAmbientTerm( Ka );
const float Id = kvsShaderDiffuseTerm( Kd, N, L );
const float Is = kvsShaderSpecularTerm( ks, S, H, N );
return ::Shade( color, Ia, Id, Is );
}
void update ( kvs::MouseEvent* event = 0 )
{
if ( event->x() > 20 && event->x() < 330 && event->y() > 20 && event->y() < 400 && m_seed_point->nvertices() > 0 )
{
const kvs::Xform x = p_main_screen->objectManager()->xform();
const float* pcoord = m_seed_point->coords().pointer();
const unsigned int nvertices = m_seed_point->nvertices();
kvs::ValueArray<float> coords( nvertices * 3 );
if ( event->button() == kvs::MouseButton::Right )
{
this->screen()->mouse()->setMode( kvs::Mouse::Translation );
this->screen()->mouse()->move( event->x(), event->y() );
kvs::Vector3f translation = this->screen()->mouse()->translation();
const kvs::Vector3f normalize = p_main_screen->objectManager()->normalize();
translation.x() /= normalize.x() * x.scaling().x();
translation.y() /= normalize.y() * x.scaling().y();
translation.z() /= normalize.z() * x.scaling().z();
for ( unsigned int i = 0; i < nvertices; i ++ )
{
kvs::Vector3f coord( pcoord );
const kvs::Vector3f new_coord = coord + translation * x.rotation();
coords[ 3 * i] = new_coord.x();
coords[ 3 * i + 1] = new_coord.y();
coords[ 3 * i + 2] = new_coord.z();
pcoord += 3;
}
m_seed_point->setCoords( coords );
}
if ( event->button() == kvs::MouseButton::Left )
{
this->screen()->mouse()->setMode( kvs::Mouse::Rotation );
this->screen()->mouse()->move( event->x(), event->y() );
kvs::Matrix33f rotation = this->screen()->mouse()->rotation().toMatrix();
for ( unsigned int i = 0; i < nvertices; i ++ )
{
kvs::Vector3f coord( pcoord );
const kvs::Vector3f new_coord = coord * rotation;
coords[ 3 * i] = new_coord.x();
coords[ 3 * i + 1] = new_coord.y();
coords[ 3 * i + 2] = new_coord.z();
pcoord += 3;
}
m_seed_point->setCoords( coords );
}
#ifdef USE_KVS
m_compositor->changeObject( m_seed_point, m_seed_point, false );
#else
m_renderer->changeObject( m_seed_point, m_point_renderer, false );
#endif
m_seed_point->updateMinMaxCoords();
const kvs::Vector3f min = m_seed_point->minObjectCoord();
const kvs::Vector3f max = m_seed_point->maxObjectCoord();
center = ( min + max ) / 2;
m_seed_point->setXMin( min.x() );
m_seed_point->setXMax( max.x() );
m_seed_point->setYMin( min.y() );
m_seed_point->setYMax( max.y() );
m_seed_point->setZMin( min.z() );
m_seed_point->setZMax( max.z() );
if ( m_seed_point->nvertices() <= 8 )
update_streamline();
}
}
void ScreenController::update(
kvs::ni::DepthGenerator& depth,
kvs::ni::UserGenerator& user )
{
if ( !m_ref_screen )
{
kvsMessageError( "kvs::ScreenBase* is not attached." );
return;
}
if ( kvs::Math::IsZero( m_p2r ) )
{
const unsigned long zpd = depth.zeroPlaneDistance();
const float zpps = depth.zeroPlanePixelSize();
m_p2r = zpps * ( 1280.0f / m_width ) / static_cast<float>( zpd );
}
kvs::ValueArray<unsigned int> users = user.users();
const float hand_level = 0.35f;
for ( size_t i = 0; i < users.size(); i++ )
{
HandList::iterator itr = m_list.begin();
kvs::tdw::HandPosition* user_hand = NULL;
while ( itr != m_list.end() )
{
if ( (*itr).user() == users[i] )
{
user_hand = &(*itr);
break;
}
itr++;
}
if ( !user_hand )
{
kvs::tdw::HandPosition hand( users[i] );
m_list.push_back( hand );
user_hand = &(m_list.back());
}
if ( user.skeleton().isTracking( users[i] ) )
{
const kvs::Vector3f neck = this->vertex_of_joint(
users[i], kvs::ni::Skeleton::Neck, depth, user );
const kvs::Vector3f left_hand = this->vertex_of_joint(
users[i], kvs::ni::Skeleton::LeftHand, depth, user );
const kvs::Vector3f right_hand = this->vertex_of_joint(
users[i], kvs::ni::Skeleton::RightHand, depth, user );
kvs::Vector3f prev_left_hand;
kvs::Vector3f prev_right_hand;
bool is_prev_left_active = false;
bool is_prev_right_active = false;
if ( !user_hand->isActive( 0 ) )
{
if ( left_hand.z() - neck.z() > hand_level )
{
user_hand->setIsActive( 0, true );
user_hand->setPosition( 0, left_hand );
}
}
else
{
prev_left_hand = user_hand->position( 0 );
if ( left_hand.z() - neck.z() > hand_level )
{
is_prev_left_active = true;
user_hand->setPosition( 0, left_hand );
}
else
{
user_hand->setIsActive( 0, false );
}
}
if ( !user_hand->isActive( 1 ) )
{
if ( right_hand.z() - neck.z() > hand_level )
{
user_hand->setIsActive( 1, true );
user_hand->setPosition( 1, right_hand );
}
}
else
{
prev_right_hand = user_hand->position( 1 );
if ( right_hand.z() - neck.z() > hand_level )
{
is_prev_right_active = true;
user_hand->setPosition( 1, right_hand );
}
else
{
user_hand->setIsActive( 1, false );
}
}
if ( user_hand->isActive( 0 ) && !user_hand->isActive( 1 ) &&
is_prev_left_active )
{
// Translation with left hand.
this->translate( prev_left_hand, user_hand->position( 0 ) );
}
else if ( !user_hand->isActive( 0 ) && user_hand->isActive( 1 ) &&
is_prev_right_active )
{
// Rotation with right hand.
this->rotate( prev_right_hand, user_hand->position( 1 ), neck );
}
else if ( user_hand->isActive( 0 ) && user_hand->isActive( 1 ) &&
is_prev_left_active && is_prev_right_active )
{
// Scaling with two hand.
this->scale( prev_left_hand, prev_right_hand,
user_hand->position( 0 ), user_hand->position( 1 ) );
}
else if ( !user_hand->isActive( 0 ) && !user_hand->isActive( 1 ) &&
itr != m_list.end() )
{
// Delete from list.
m_list.erase( itr );
}
}
if ( this->is_cross_pose( users[i], depth, user ) )
{
m_ref_screen->reset();
kvs::KeyEvent event;
event.setKey( kvs::Key::Home );
m_ref_sender->sendKeyEvent( &event );
}
}
}
void pressed()
{
#ifdef WIN32
std::string default_volume1( "D:\\Koron\\Dropbox\\Work\\Viz\\Hyperstreamline\\data\\engine\\v6engine_stress_and_mises.kvsml" );
#else
std::string default_volume1( "../../data/engine/v6engine_stress_and_mises.kvsml" );
#endif
if ( p_arg->hasOption( "volume1" ) )
m_volume1 = new kvs::UnstructuredVolumeImporter( p_arg->optionValue<std::string>("volume1") );
else
m_volume1 = new kvs::UnstructuredVolumeImporter( default_volume1 );
if ( m_volume1->veclen() != 6 && m_volume1->veclen() != 7 )
{
p_pb_info->setCaption( "Veclen wrong!" );
return;
}
// initialize sliders
const kvs::Vector3f min_coord = m_volume1->minExternalCoord();
const kvs::Vector3f max_coord = m_volume1->maxExternalCoord();
xmin = min_coord.x();
ymin = min_coord.y();
zmin = min_coord.z();
xmax = max_coord.x();
ymax = max_coord.y();
zmax = max_coord.z();
center.x() = ( xmin + xmax ) / 2;
center.y() = ( ymin + ymax ) / 2;
center.z() = ( zmin + zmax ) / 2;
resx = 10;
resy = 10;
resz = 10;
const float dx = xmax - xmin;
const float dy = ymax - ymin;
const float dz = zmax - zmin;
p_sld0->setValue( dx );
p_sld0->setRange( 0.0, dx );
p_sld0->activate();
p_sld1->setValue( dy );
p_sld1->setRange( 0.0, dy );
p_sld1->activate();
p_sld2->setValue( dz );
p_sld2->setRange( 0, dz );
p_sld2->activate();
p_sld3->setValue( resx );
p_sld3->setRange( 0, 30 );
p_sld3->activate();
p_sld4->setValue( resy );
p_sld4->setRange( 0, 30 );
p_sld4->activate();
p_sld5->setValue( resz );
p_sld5->setRange( 0, 30 );
p_sld5->activate();
m_seed_point->setResX( resx );
m_seed_point->setResY( resy );
m_seed_point->setResZ( resz );
m_seed_point->setXMin( xmin );
m_seed_point->setXMax( xmax );
m_seed_point->setYMin( ymin );
m_seed_point->setYMax( ymax );
m_seed_point->setZMin( zmin );
m_seed_point->setZMax( zmax );
m_seed_point->reset_coordinates();
m_seed_point->setMinMaxObjectCoords( m_volume1->minObjectCoord(), m_volume1->maxObjectCoord() );
m_seed_point->setMinMaxExternalCoords( m_volume1->minExternalCoord(), m_volume1->maxExternalCoord() );
#ifdef USE_KVS
#else
m_renderer->changeObject( m_seed_point, m_point_renderer, false );
#endif
p_pb_info->setCaption( "Tensor Volume Read!" );
std::cout << "Tensor Volume Read" << std::endl;
this->deactivate();
}
int main( int argc, char** argv )
{
kvs::glut::Application app( argc, argv );
Argument arg( app.argc(), app.argv() );
p_arg = &arg;
// for empty objects
std::vector<kvs::Real32> coords;
std::vector<kvs::UInt32> connections;
std::vector<kvs::UInt8> colors;
std::vector<float> values;
std::vector<float> eigenvalues;
colors.push_back(255);
colors.push_back(255);
colors.push_back(255);
for ( unsigned int i = 0; i < 3; i++ )
{
coords.push_back(0.0);
}
for ( unsigned int i = 0; i < 2; i ++ )
{
connections.push_back(0);
values.push_back(0.0);
}
eigenvalues.push_back(0);
// Volume 2 (Displacement)
m_volume2 = new kvs::UnstructuredVolumeObject();
m_volume2->setCellType( kvs::UnstructuredVolumeObject::Tetrahedra );
m_volume2->setConnections( kvs::ValueArray<kvs::UInt32>( connections ) );
m_volume2->setCoords( kvs::ValueArray<float>( coords ) );
m_volume2->setValues( kvs::AnyValueArray( values ) );
m_volume2->setNCells(0);
m_volume2->setNNodes(0);
// polygon (Empty External)
#ifdef WIN32
std::string default_polygon( "D:\\Koron\\Dropbox\\Work\\Viz\\Hyperstreamline\\data\\engine\\v6engine_external_face.kvsml" );
#else
std::string default_polygon( "../../data/engine/v6engine_external_face.kvsml" );
#endif
if ( p_arg->hasOption( "polygon" ) )
{
kvs::PolygonObject* import_polygon = new kvs::PolygonImporter( p_arg->optionValue<std::string>("polygon") );
m_polygon = new kvs::PolygonToPolygon( import_polygon );
}
else
{
kvs::PolygonObject* import_polygon = new kvs::PolygonImporter( default_polygon );
m_polygon = new kvs::PolygonToPolygon( import_polygon );
}
if ( !m_polygon )
{
kvsMessageError( "Cannot create surface." );
exit( EXIT_FAILURE );
}
m_polygon->setOpacity( opacity_polygon );
m_polygon->setColor( kvs::RGBColor( 255,255,255 ) );
const kvs::Vector3f min_coord = m_polygon->minExternalCoord();
const kvs::Vector3f max_coord = m_polygon->maxExternalCoord();
xmin = min_coord.x();
ymin = min_coord.y();
zmin = min_coord.z();
xmax = max_coord.x();
ymax = max_coord.y();
zmax = max_coord.z();
resx = 10;
resy = 10;
resz = 10;
m_seed_point = new kvs::CubicPointObject();
m_seed_point->reset_coordinates( resx, resy, resz, xmin, xmax, ymin, ymax, zmin, zmax );
m_seed_point->updateMinMaxCoords();
// streamlines (Empty LineObject)
m_streamline = new kvs::HyperStreamline();
m_streamline->setLineType( kvs::LineObject::Polyline );
m_streamline->setColorType( kvs::LineObject::VertexColor );
m_streamline->setCoords( kvs::ValueArray<kvs::Real32>( coords ) );
m_streamline->setConnections( kvs::ValueArray<kvs::UInt32>( connections ) );
m_streamline->setEigenValues( eigenvalues );
m_streamline->setColors( kvs::ValueArray<kvs::UInt8>( colors ) );
m_streamline->setSize( 1.0f );
// main screen
kvs::glut::Screen main_screen( &app );
p_main_screen = &main_screen;
//main_screen.background()->setColor( kvs::RGBAColor( 0, 0, 0, 1 ) );
int interval = 30;
kvs::glut::Timer timer( interval );
TimerEvent timer_event;
KeyPressEvent keypress_event;
main_screen.addTimerEvent( &timer_event, &timer );
main_screen.addKeyPressEvent( &keypress_event );
main_screen.show();
// renderer
#ifdef USE_KVS
m_compositor = new kvs::glew::StochasticRenderingCompositor( &main_screen );
m_compositor->enableLODControl();
m_tfunc.adjustRange( m_volume2 );
m_tfunc.setColorMap( kvs::RGBFormulae::AFMHot(256) );
m_volume_renderer = new kvs::glew::StochasticTetrahedraEngine();
m_volume_renderer->setTransferFunction( m_tfunc );
m_volume_renderer->setShader( kvs::Shader::BlinnPhong() );
m_volume_renderer->disableShading();
m_volume_renderer->setEdgeSize( 2 );
m_polygon_renderer = new kvs::glew::StochasticPolygonEngine();
m_polygon_renderer->setShader( kvs::Shader::BlinnPhong() );
m_point_renderer = new kvs::glew::StochasticPointEngine();
m_point_renderer->disableShading();
m_line_renderer = new kvs::glew::StochasticLineEngine();
m_line_renderer->setShader( kvs::Shader::BlinnPhong() );
m_line_renderer->setOpacity( opacity_line );
m_compositor->registerObject( m_volume2, m_volume_renderer );
m_compositor->registerObject( m_polygon, m_polygon_renderer );
m_compositor->registerObject( m_seed_point, m_point_renderer );
m_compositor->registerObject( m_streamline, m_line_renderer );
#else
m_renderer = new kvs::glew::StochasticRenderer( 1 );
m_renderer->enableLODControl();
m_tfunc.adjustRange( m_volume2 );
m_tfunc.setColorMap( kvs::RGBFormulae::AFMHot(256) );
m_volume_renderer = new kvs::glew::StochasticVolumeRenderer( m_volume2 );
m_volume_renderer->setTransferFunction( m_tfunc );
m_volume_renderer->setShader( kvs::Shader::BlinnPhong() );
m_volume_renderer->disableShading();
m_volume_renderer->setEdgeSize( 2 );
m_renderer->registerRenderer( m_volume_renderer );
m_polygon_renderer = new kvs::glew::StochasticPolygonRenderer( m_polygon );
m_polygon_renderer->setShader( kvs::Shader::BlinnPhong() );
m_renderer->registerRenderer( m_polygon_renderer );
m_point_renderer = new kvs::glew::StochasticPointRenderer( m_seed_point );
m_point_renderer->disableShading();
m_renderer->registerRenderer( m_point_renderer );
m_line_renderer = new kvs::glew::StochasticLineRenderer( m_streamline );
m_line_renderer->setShader( kvs::Shader::BlinnPhong() );
m_line_renderer->setOpacity( opacity_line );
m_renderer->registerRenderer( m_line_renderer );
null = new::kvs::NullObject( m_seed_point );
null->setName( "null" );
main_screen.registerObject( null, m_renderer );
main_screen.show();
#endif
// tfunc editor
//TransferFunctionEditor editor( &main_screen, m_renderer, m_volume_renderer );
//editor.setVolumeObject( m_volume2 );
//editor.show();
//kvs::ControlScreen control_screen( &app );
MouseMoveEvent mouse_move_event;
kvs::glut::Screen control_screen( &app );
//control_screen.addMouseMoveEvent( &mouse_move_event );
control_screen.setMouseMoveEvent( &mouse_move_event );
control_screen.setTitle( "kvs::ControlScreen" );
control_screen.setGeometry( 512, 0, 600, 560 );
#ifdef USE_KVS
//control_screen.attachMainScreen( p_main_screen, m_seed_point, m_compositor, m_point_renderer );
#else
//control_screen.attachMainScreen( p_main_screen, m_seed_point, m_renderer, m_point_renderer );
#endif
control_screen.show();
PaintEvent paint_event;
control_screen.addPaintEvent( &paint_event );
const int width = control_screen.width();
const int height = control_screen.height();
const int ui_width = 240;
PB_INFO pb_info( &control_screen );
p_pb_info = &pb_info;
pb_info.setX( width/6 );
pb_info.setY( height - 40 );
pb_info.setWidth( 400 );
pb_info.setMargin( 5 );
pb_info.setTextMargin( 5 );
pb_info.setCaption("");
//pb_info.deactivate();
pb_info.show();
PB00 pb00( &control_screen );
p_pb00 = &pb00;
pb00.setX( width - ui_width );
pb00.setY( 10 );
pb00.setWidth( 220 );
pb00.setMargin( 5 );
pb00.setTextMargin( 5 );
pb00.setCaption("Read volume1(Stress)");
pb00.show();
PB01 pb01( &control_screen );
p_pb01 = &pb01;
pb01.setX( pb00.x() );
pb01.setY( pb00.y() + pb00.height() );
pb01.setWidth( 220 );
pb01.setMargin( 5 );
pb01.setTextMargin( 5 );
pb01.setCaption("Read volume2(Displacement)");
pb01.deactivate();
pb01.show();
PB02 pb02( &control_screen );
p_pb02 = &pb02;
pb02.setX( pb01.x() );
pb02.setY( pb01.y() + pb01.height() );
pb02.setWidth( 220 );
pb02.setMargin( 5 );
pb02.setTextMargin( 5 );
pb02.setCaption("Hide Polygon");
//pb02.deactivate();
pb02.show();
PB03 pb03( &control_screen );
p_pb03 = &pb03;
pb03.setX( pb02.x() );
pb03.setY( pb02.y() + pb02.height() );
pb03.setWidth( 220 );
pb03.setMargin( 5 );
pb03.setTextMargin( 5 );
pb03.setCaption("Read CellTree(Optional)");
//pb03.deactivate();
pb03.show();
SLD0 sld0( &control_screen );
p_sld0 = &sld0;
sld0.setX( pb03.x() );
sld0.setY( pb03.y() + pb03.height() );
sld0.setWidth( 220 );
sld0.setMargin( 0 );
sld0.setCaption("dx");
//sld0.deactivate();
sld0.show();
SLD1 sld1( &control_screen );
p_sld1 = &sld1;
sld1.setX( sld0.x() );
sld1.setY( sld0.y() + sld0.height() );
sld1.setWidth( 220 );
sld1.setMargin( 0 );
sld1.setCaption("dy");
//sld1.deactivate();
sld1.show();
SLD2 sld2( &control_screen );
p_sld2 = &sld2;
sld2.setX( sld1.x() );
sld2.setY( sld1.y() + sld1.height() );
sld2.setWidth( 220 );
sld2.setMargin( 0 );
sld2.setCaption("dz");
//sld2.deactivate();
sld2.show();
SLD3 sld3( &control_screen );
p_sld3 = &sld3;
sld3.setX( sld2.x() );
sld3.setY( sld2.y() + sld2.height() );
sld3.setWidth( 220 );
sld3.setMargin( 0 );
sld3.setCaption("resx");
//sld3.deactivate();
sld3.show();
SLD4 sld4( &control_screen );
p_sld4 = &sld4;
sld4.setX( sld3.x() );
sld4.setY( sld3.y() + sld3.height() );
sld4.setWidth( 220 );
sld4.setMargin( 0 );
sld4.setCaption("resy");
//sld4.deactivate();
sld4.show();
SLD5 sld5( &control_screen );
p_sld5 = &sld5;
sld5.setX( sld4.x() );
sld5.setY( sld4.y() + sld4.height() );
sld5.setWidth( 220 );
sld5.setMargin( 0 );
sld5.setCaption("resz");
//sld5.deactivate();
sld5.show();
PB04 pb04( &control_screen );
p_pb04 = &pb04;
pb04.setX( sld5.x() );
pb04.setY( sld5.y() + sld5.height() );
pb04.setWidth( 220 );
pb04.setMargin( 15 );
pb04.setTextMargin( 5 );
pb04.setCaption("Update Streamline");
//pb04.deactivate();
pb04.show();
PB05 pb05( &control_screen );
p_pb05 = &pb05;
pb05.setX( 10 );
pb05.setY( pb04.y() + 10 );
pb05.setWidth( 120 );
pb05.setMargin( 5 );
pb05.setTextMargin( 5 );
pb05.setCaption("Buffer Line");
//pb04.deactivate();
pb05.show();
PB06 pb06( &control_screen );
p_pb06 = &pb06;
pb06.setX( pb05.x() + pb05.width() );
pb06.setY( pb05.y() );
pb06.setWidth( 80 );
pb06.setMargin( 5 );
pb06.setTextMargin( 5 );
pb06.setCaption("Clear");
//pb04.deactivate();
pb06.show();
PB07 pb07( &control_screen );
p_pb07 = &pb07;
pb07.setX( pb06.x() + pb06.width() );
pb07.setY( pb06.y() );
pb07.setWidth( 160 );
pb07.setMargin( 5 );
pb07.setTextMargin( 5 );
pb07.setCaption("Save CellTree.dat");
//pb04.deactivate();
pb07.show();
RB00 rb00( &control_screen );
rb00.setX( pb05.x() );
rb00.setY( pb05.y() - pb05.height() );
rb00.setWidth( 100 );
rb00.setMargin( 15 );
rb00.setCaption( "Principal" );
rb00.setState( "true" );
RB01 rb01( &control_screen );
rb01.setX( rb00.x() + rb00.width() );
rb01.setY( rb00.y() );
rb01.setWidth( 130 );
rb01.setMargin( 15 );
rb01.setCaption( "Intermediate" );
RB02 rb02( &control_screen );
rb02.setX( rb01.x() + rb01.width() );
rb02.setY( rb01.y() );
rb02.setWidth( 100 );
rb02.setMargin( 15 );
rb02.setCaption( "Minor" );
kvs::glut::RadioButtonGroup rbg0( &control_screen );
rbg0.add( &rb00 );
rbg0.add( &rb01 );
rbg0.add( &rb02 );
rbg0.show();
CB00 cb00( &control_screen );
cb00.setX( rb00.x() + rb00.width() );
cb00.setY( rb00.y() - rb00.height() );
cb00.setWidth( 100 );
cb00.setMargin( 25 );
cb00.setCaption( "Cache" );
cb00.setState( true );
cb00.show();
kvs::ColorMap cmap;
cmap.setRange( -127, 127 );
cmap.create();
kvs::glut::LegendBar legend_bar( &main_screen );
legend_bar.setColorMap( cmap );
legend_bar.show();
return( app.run() );
}
void MarchingPyramid::extract_surfaces_with_duplication(
const kvs::UnstructuredVolumeObject* volume )
{
// Calculated the coordinate data array and the normal vector array.
std::vector<kvs::Real32> coords;
std::vector<kvs::Real32> normals;
const kvs::UInt32 ncells( volume->numberOfCells() );
const kvs::UInt32* connections =
static_cast<const kvs::UInt32*>( volume->connections().data() );
// Extract surfaces.
size_t index = 0;
size_t local_index[5];
for ( kvs::UInt32 cell = 0; cell < ncells; ++cell, index += 5 )
{
// Calculate the indices of the target cell.
local_index[0] = connections[ index + 0 ];
local_index[1] = connections[ index + 1 ];
local_index[2] = connections[ index + 2 ];
local_index[3] = connections[ index + 3 ];
local_index[4] = connections[ index + 4 ];
// Calculate the index of the reference table.
size_t table_index = this->calculate_table_index<T>( local_index );
if ( table_index == 0 ) continue;
if ( table_index == 10 || table_index == 11 || table_index == 20 || table_index == 21 ){
table_index = this->calculate_special_table_index<T>( local_index, table_index );
}
if ( table_index == 36 ) continue;
// Calculate the triangle polygons.
for ( size_t i = 0; MarchingPyramidTable::TriangleID[ table_index ][i] != -1; i += 3 )
{
// Refer the edge IDs from the TriangleTable by using the table_index.
const int e0 = MarchingPyramidTable::TriangleID[table_index][i];
const int e1 = MarchingPyramidTable::TriangleID[table_index][i+2];
const int e2 = MarchingPyramidTable::TriangleID[table_index][i+1];
// Determine vertices for each edge.
const int v0 = local_index[MarchingPyramidTable::VertexID[e0][0]];
const int v1 = local_index[MarchingPyramidTable::VertexID[e0][1]];
const int v2 = local_index[MarchingPyramidTable::VertexID[e1][0]];
const int v3 = local_index[MarchingPyramidTable::VertexID[e1][1]];
const int v4 = local_index[MarchingPyramidTable::VertexID[e2][0]];
const int v5 = local_index[MarchingPyramidTable::VertexID[e2][1]];
// Calculate coordinates of the vertices which are composed
// of the triangle polygon.
const kvs::Vector3f vertex0( this->interpolate_vertex<T>( v0, v1 ) );
coords.push_back( vertex0.x() );
coords.push_back( vertex0.y() );
coords.push_back( vertex0.z() );
const kvs::Vector3f vertex1( this->interpolate_vertex<T>( v2, v3 ) );
coords.push_back( vertex1.x() );
coords.push_back( vertex1.y() );
coords.push_back( vertex1.z() );
const kvs::Vector3f vertex2( this->interpolate_vertex<T>( v4, v5 ) );
coords.push_back( vertex2.x() );
coords.push_back( vertex2.y() );
coords.push_back( vertex2.z() );
// Calculate a normal vector for the triangle polygon.
const kvs::Vector3f normal( ( vertex1 - vertex0 ).cross( vertex2 - vertex0 ) );
normals.push_back( normal.x() );
normals.push_back( normal.y() );
normals.push_back( normal.z() );
} // end of loop-triangle
} // end of loop-cell
// Calculate the polygon color for the isolevel.
const kvs::RGBColor color = this->calculate_color<T>();
if( coords.size() > 0 ){
SuperClass::setCoords( kvs::ValueArray<kvs::Real32>( coords ) );
SuperClass::setColor( color );
SuperClass::setNormals( kvs::ValueArray<kvs::Real32>( normals ) );
SuperClass::setOpacity( 255 );
SuperClass::setPolygonType( kvs::PolygonObject::Triangle );
SuperClass::setColorType( kvs::PolygonObject::PolygonColor );
SuperClass::setNormalType( kvs::PolygonObject::PolygonNormal );
}
}
void StructuredVolumeImporter::import( const kvs::DicomList* dicom_list )
{
if ( dicom_list->size() == 0 )
{
BaseClass::setSuccess( false );
kvsMessageError("Dicom file is not included.");
return;
}
const float spacing = static_cast<float>( dicom_list->sliceSpacing() );
const float thickness = static_cast<float>( dicom_list->sliceThickness() );
const size_t x_size = dicom_list->width();
const size_t y_size = dicom_list->height();
const size_t z_size = dicom_list->nslices();
const float x_ratio = dicom_list->pixelSpacing()[0];
const float y_ratio = dicom_list->pixelSpacing()[1];
const float z_ratio = kvs::Math::IsZero( spacing ) ? kvs::Math::IsZero( thickness ) ? x_ratio : thickness : spacing;
const kvs::Vector3f min_obj_coord( 0.0f, 0.0f, 0.0f );
const kvs::Vector3f max_obj_coord( x_size - 1.0f, y_size - 1.0f, z_size - 1.0f );
SuperClass::setMinMaxObjectCoords( min_obj_coord, max_obj_coord );
const kvs::Vector3f min_ext_coord( min_obj_coord );
const kvs::Vector3f max_ext_coord( max_obj_coord.x() * x_ratio,
max_obj_coord.y() * y_ratio,
max_obj_coord.z() * z_ratio );
SuperClass::setMinMaxExternalCoords( min_ext_coord, max_ext_coord );
bool shift = true;
const kvs::Dicom* dicom = (*dicom_list)[0];
const kvs::UInt32 bits_allocated = dicom->bitsAllocated();
const bool pixel_representation = dicom->pixelRepresentation();
switch ( bits_allocated )
{
case 8:
{
const kvs::AnyValueArray values = this->get_dicom_data<kvs::UInt8>( dicom_list, false );
SuperClass::setValues( values );
break;
}
case 16:
{
if ( pixel_representation )
{
const kvs::AnyValueArray values = this->get_dicom_data<kvs::UInt16>( dicom_list, false );
SuperClass::setValues( values );
}
else
{
if ( shift )
{
const kvs::AnyValueArray values = this->get_dicom_data<kvs::UInt16>( dicom_list, true );
SuperClass::setValues( values );
}
else
{
const kvs::AnyValueArray values = this->get_dicom_data<kvs::Int16>( dicom_list, false );
SuperClass::setValues( values );
}
}
break;
}
default: break;
}
const kvs::Vector3ui resolution( x_size, y_size, z_size );
SuperClass::setGridType( kvs::StructuredVolumeObject::Uniform );
SuperClass::setResolution( resolution );
SuperClass::setVeclen( 1 );
SuperClass::updateMinMaxValues();
}