/*===========================================================================*/
StructuredVolumeImporter::SuperClass* StructuredVolumeImporter::exec( const kvs::FileFormatBase* file_format )
{
if ( !file_format )
{
BaseClass::setSuccess( false );
kvsMessageError("Input file format is NULL.");
return NULL;
}
if ( const kvs::KVSMLObjectStructuredVolume* volume = dynamic_cast<const kvs::KVSMLObjectStructuredVolume*>( file_format ) )
{
this->import( volume );
}
else if ( const kvs::AVSField* volume = dynamic_cast<const kvs::AVSField*>( file_format ) )
{
this->import( volume );
}
else if ( const kvs::DicomList* volume = dynamic_cast<const kvs::DicomList*>( file_format ) )
{
this->import( volume );
}
else
{
BaseClass::setSuccess( false );
kvsMessageError("Input file format is not supported.");
return NULL;
}
return this;
}
/*===========================================================================*/
HitAndMissSampling::SuperClass* HitAndMissSampling::exec( const kvs::ObjectBase* object )
{
if ( !object )
{
BaseClass::setSuccess( false );
kvsMessageError("Input object is NULL.");
return( NULL );
}
const kvs::VolumeObjectBase* volume = kvs::VolumeObjectBase::DownCast( object );
if ( !volume )
{
BaseClass::setSuccess( false );
kvsMessageError("Input object is not volume dat.");
return( NULL );
}
const kvs::VolumeObjectBase::VolumeType volume_type = volume->volumeType();
if ( volume_type == kvs::VolumeObjectBase::Structured )
{
this->mapping( reinterpret_cast<const kvs::StructuredVolumeObject*>( object ) );
}
else // volume_type == kvs::VolumeObjectBase::Unstructured
{
this->mapping( reinterpret_cast<const kvs::UnstructuredVolumeObject*>( object ) );
}
return( this );
}
int main( int argc, char** argv )
{
Argument arg( argc, argv );
kvs::glut::Application app( argc, argv );
kvs::glut::Screen screen( &app );
screen.setTitle( "kvs::glew::ShadowMapRenderer" );
// Add user key press event.
KeyPressEvent key_press_event;
screen.addKeyPressEvent( &key_press_event );
screen.show();
kvs::PolygonObject* object = new kvs::PolygonImporter( arg.value<std::string>() );
if ( !object )
{
kvsMessageError( "Cannot read polygon object." );
return( EXIT_FAILURE );
}
g_renderer = new kvs::glew::ShadowMapRenderer( &screen );
if ( !g_renderer )
{
kvsMessageError( "Cannot allocate renderer." );
delete object;
return( EXIT_FAILURE );
}
screen.registerObject( object, g_renderer );
return( app.run() );
}
/*===========================================================================*/
PolygonToPolygon::SuperClass* PolygonToPolygon::exec( const kvs::ObjectBase* object )
{
if ( !object )
{
BaseClass::m_is_success = false;
kvsMessageError( "Input object is NULL." );
return( NULL );
}
const kvs::PolygonObject* polygon = kvs::PolygonObject::DownCast( object );
if ( !polygon )
{
BaseClass::m_is_success = false;
kvsMessageError( "Input object is not supported." );
return( NULL );
}
if ( polygon->polygonType() == kvs::PolygonObject::Triangle )
{
this->calculate_triangle_connections( polygon );
this->calculate_triangle_normals();
}
else
{
BaseClass::m_is_success = false;
kvsMessageError( "Input polygon type is not supported." );
return( NULL );
}
SuperClass::updateMinMaxCoords();
BaseClass::m_is_success = true;
return( this );
}
/*===========================================================================*/
bool Gis::read( const std::string& filenames )
{
BaseClass::setFilename( filenames );
BaseClass::setSuccess( true );
if ( kvs::Directory( filenames ).isDirectory() )
{
kvs::Directory directory( filenames );
const size_t nfiles = directory.fileList().size();
for ( size_t i = 0; i < nfiles; i++ )
{
const std::string file = directory.fileList().at(i).filePath( true );
if ( !this->read_mesh( file ) )
{
kvsMessageError("Cannot read the mesh data.");
BaseClass::setSuccess( false );
return false;
}
}
}
else
{
const std::string file = filenames;
if ( !this->read_mesh( file ) )
{
kvsMessageError("Cannot read the mesh data.");
BaseClass::setSuccess( false );
return false;
}
}
float min_latitude = 9999.0f;
float max_latitude = -9999.0f;
float min_longitude = 9999.0f;
float max_longitude = -9999.0f;
float min_height = 9999.0f;
float max_height = -9999.0f;
for ( size_t i = 0; i < m_meshes.size(); i++ )
{
if ( m_meshes[i]->hasData() )
{
min_latitude = kvs::Math::Min( min_latitude, m_meshes[i]->area().minLatitude() );
max_latitude = kvs::Math::Max( max_latitude, m_meshes[i]->area().maxLatitude() );
min_longitude = kvs::Math::Min( min_longitude, m_meshes[i]->area().minLongitude() );
max_longitude = kvs::Math::Max( max_longitude, m_meshes[i]->area().maxLongitude() );
min_height = kvs::Math::Min( min_height, m_meshes[i]->area().minHeight() );
max_height = kvs::Math::Max( max_height, m_meshes[i]->area().maxHeight() );
}
}
m_area.setMinLatitude( min_latitude );
m_area.setMaxLatitude( max_latitude );
m_area.setMinLongitude( min_longitude );
m_area.setMaxLongitude( max_longitude );
m_area.setMinHeight( min_height );
m_area.setMaxHeight( max_height );
return true;
}
const bool HandsGenerator::create( kvs::ni::Context& context )
{
if ( m_is_created )
{
kvsMessageError( "HandsGenerator is already created." );
return( false );
}
{
XnStatus status = m_generator.Create( context.context() );
if ( status != XN_STATUS_OK )
{
kvsMessageError( "%s error: <%s>.",
xnGetStatusName( status ),
xnGetStatusString( status ) );
return( false );
}
}
{
XnStatus status = m_generator.RegisterHandCallbacks(
HandCreateEvent, HandUpdateEvent, HandDestroyEvent, NULL, m_handler );
if ( status != XN_STATUS_OK )
{
kvsMessageError( "%s error: <%s>.",
xnGetStatusName( status ),
xnGetStatusString( status ) );
return( false );
}
}
m_is_created = true;
return( true );
}
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 ) );
}
/*===========================================================================*/
int main( int argc, char** argv )
{
// GLUT viewer application.
kvs::glut::Application app( argc, argv );
// Create an image object.
const std::string filename( argc > 1 ? argv[1] : "" );
kvs::ImageObject* object = new kvs::ImageImporter( filename );
if ( !object )
{
kvsMessageError("Cannot creat an image object.");
return( false );
}
// Create an image renderer.
const kvs::ImageRenderer::Type type = kvs::ImageRenderer::Stretching;
kvs::ImageRenderer* renderer = new kvs::ImageRenderer( type );
if ( !renderer )
{
kvsMessageError("Cannot create an image renderer.");
delete object;
return( false );
}
// Screen.
kvs::glut::Screen screen( &app );
screen.registerObject( object, renderer );
screen.setSize( object->width(), object->height() );
screen.setTitle( "kvs::ImageRenderer" );
screen.show();
return( app.run() );
}
/*===========================================================================*/
bool VisualizationPipeline::import()
{
if ( !this->hasObject() )
{
// Check filename.
if ( m_filename.empty() )
{
kvsMessageError( "Input data is not specified." );
return false;
}
// Import object.
kvs::ObjectImporter importer( m_filename );
kvs::ObjectBase* object = importer.import();
if ( !object )
{
kvsMessageError( "Cannot import an object." );
return false;
}
// Attache the imported object.
m_object = object;
}
return true;
}
/*==========================================================================*/
void MarchingPyramid::mapping( const kvs::UnstructuredVolumeObject* volume )
{
// Check whether the volume can be processed or not.
if ( volume->veclen() != 1 )
{
kvsMessageError("The input volume is not a sclar field data.");
return;
}
// Attach the pointer to the volume object.
BaseClass::attachVolume( volume );
BaseClass::setRange( volume );
BaseClass::setMinMaxCoords( volume, this );
// Extract surfaces.
const std::type_info& type = volume->values().typeInfo()->type();
if ( type == typeid( kvs::Int8 ) ) this->extract_surfaces<kvs::Int8>( volume );
else if ( type == typeid( kvs::Int16 ) ) this->extract_surfaces<kvs::Int16>( volume );
else if ( type == typeid( kvs::Int32 ) ) this->extract_surfaces<kvs::Int32>( volume );
else if ( type == typeid( kvs::Int64 ) ) this->extract_surfaces<kvs::Int64>( volume );
else if ( type == typeid( kvs::UInt8 ) ) this->extract_surfaces<kvs::UInt8>( volume );
else if ( type == typeid( kvs::UInt16 ) ) this->extract_surfaces<kvs::UInt16>( volume );
else if ( type == typeid( kvs::UInt32 ) ) this->extract_surfaces<kvs::UInt32>( volume );
else if ( type == typeid( kvs::UInt64 ) ) this->extract_surfaces<kvs::UInt64>( volume );
else if ( type == typeid( kvs::Real32 ) ) this->extract_surfaces<kvs::Real32>( volume );
else if ( type == typeid( kvs::Real64 ) ) this->extract_surfaces<kvs::Real64>( volume );
else
{
kvsMessageError("Unsupported data type '%s' of the volume.",
volume->values().typeInfo()->typeName() );
}
}
/*===========================================================================*/
kvs::ObjectBase* MarchingPyramid::exec( const kvs::ObjectBase* object )
{
const kvs::ObjectBase::ObjectType object_type = object->objectType();
if ( object_type == kvs::ObjectBase::Geometry )
{
kvsMessageError("Geometry object is not supported.");
return NULL;
}
// In the case of VertexNormal-type, the duplicated vertices are forcibly deleted.
if ( SuperClass::normalType() == kvs::PolygonObject::VertexNormal )
{
m_duplication = false;
}
const kvs::VolumeObjectBase* volume = reinterpret_cast<const kvs::VolumeObjectBase*>( object );
const kvs::VolumeObjectBase::VolumeType volume_type = volume->volumeType();
if ( volume_type == kvs::VolumeObjectBase::Unstructured )
{
this->mapping( reinterpret_cast<const kvs::UnstructuredVolumeObject*>( object ) );
}
else // volume_type == kvs::VolumeObjectBase::Unstructured
{
kvsMessageError("Unstructured volume object is not supported.");
return NULL;
}
return this;
}
/*===========================================================================*/
void SphereGlyph::exec( kvs::ObjectBase* object, kvs::Camera* camera, kvs::Light* light )
{
kvs::IgnoreUnusedVariable( light );
kvs::IgnoreUnusedVariable( camera );
if ( object->objectType() == kvs::ObjectBase::Geometry )
{
const kvs::GeometryObjectBase* geometry = kvs::GeometryObjectBase::DownCast( object );
if ( geometry->geometryType() == kvs::GeometryObjectBase::Point )
{
const kvs::PointObject* point = kvs::PointObject::DownCast( geometry );
if ( !point ) { kvsMessageError("Input object is not point dat."); return; }
if ( m_point != point ) { this->attach_point( point ); }
}
}
else if ( object->objectType() == kvs::ObjectBase::Volume )
{
const kvs::VolumeObjectBase* volume = kvs::VolumeObjectBase::DownCast( object );
if ( !volume ) { kvsMessageError("Input object is not volume dat."); return; }
if ( m_volume != volume ) { this->attach_volume( volume ); }
}
BaseClass::startTimer();
kvs::OpenGL::WithPushedAttrib p( GL_ALL_ATTRIB_BITS );
kvs::OpenGL::Enable( GL_DEPTH_TEST );
this->initialize();
this->draw();
BaseClass::stopTimer();
}
/*===========================================================================*/
bool TableObjectTag::write( kvs::XMLNode::SuperClass* parent )
{
kvs::XMLElement element( BaseClass::name() );
if ( m_has_nrows )
{
element.setAttribute( "nrows", m_nrows );
}
else
{
kvsMessageError( "'nrows' is not specified in <%s>.", BaseClass::name().c_str() );
return false;
}
if ( m_has_ncolumns )
{
element.setAttribute( "ncolumns", m_ncolumns );
}
else
{
kvsMessageError( "'ncolumns' is not specified in <%s>.", BaseClass::name().c_str() );
return false;
}
return BaseClass::write_with_element( parent, element );
}
/*===========================================================================*/
ExtractEdges::SuperClass* ExtractEdges::exec( const kvs::ObjectBase* object )
{
if ( !object )
{
BaseClass::setSuccess( false );
kvsMessageError("Input object is NULL.");
return NULL;
}
const kvs::VolumeObjectBase* volume = kvs::VolumeObjectBase::DownCast( object );
if ( !volume )
{
BaseClass::setSuccess( false );
kvsMessageError("Input object is not volume dat.");
return NULL;
}
const kvs::VolumeObjectBase::VolumeType type = volume->volumeType();
if ( type == kvs::VolumeObjectBase::Structured )
{
this->mapping( kvs::StructuredVolumeObject::DownCast( volume ) );
}
else // type == kvs::VolumeObjectBase::Unstructured
{
this->mapping( kvs::UnstructuredVolumeObject::DownCast( volume ) );
}
return this;
}
/*===========================================================================*/
LineImporter::LineImporter( const std::string& filename )
{
if ( kvs::KVSMLObjectLine::CheckExtension( filename ) )
{
kvs::KVSMLObjectLine* file_format = new kvs::KVSMLObjectLine( filename );
if( !file_format )
{
BaseClass::setSuccess( false );
kvsMessageError("Cannot read '%s'.",filename.c_str());
return;
}
if( file_format->isFailure() )
{
BaseClass::setSuccess( false );
kvsMessageError("Cannot read '%s'.",filename.c_str());
delete file_format;
return;
}
this->import( file_format );
delete file_format;
}
else
{
BaseClass::setSuccess( false );
kvsMessageError("Cannot import '%s'.",filename.c_str());
return;
}
}
/*===========================================================================*/
bool GriddedBinaryDataFile::load() const
{
if ( m_filename.length() == 0 )
{
kvsMessageError("Filename of binary data has not been specified.");
return false;
}
std::ifstream ifs( m_filename.c_str(), std::ios::binary | std::ios::in );
if( !ifs.is_open() )
{
kvsMessageError( "Cannot open %s.", m_filename.c_str() );
return false;
}
ifs.seekg( 0, std::ios::end );
const std::streamoff end = ifs.tellg();
ifs.seekg( 0, std::ios::beg );
const std::streamoff begin = ifs.tellg();
const std::streamoff file_size = end - begin; // [byte]
if ( m_sequential )
{
const size_t element_size = sizeof( kvs::Real32 ) + 4 * sizeof( kvs::Int16 );
const size_t nelements = static_cast<size_t>( file_size / element_size );
m_values.allocate( nelements );
for ( size_t i = 0; i < nelements; i++ )
{
kvs::Int16 padding[4];
kvs::Real32 value;
ifs.read( (char*)( padding + 0 ), sizeof( kvs::Int16 ) );
ifs.read( (char*)( padding + 1 ), sizeof( kvs::Int16 ) );
ifs.read( (char*)( &value ), sizeof( kvs::Real32 ) );
ifs.read( (char*)( padding + 2 ), sizeof( kvs::Int16 ) );
ifs.read( (char*)( padding + 3 ), sizeof( kvs::Int16 ) );
m_values[i] = value;
}
}
else
{
const size_t element_size = sizeof( kvs::Real32 );
const size_t nelements = static_cast<size_t>( file_size / element_size );
m_values.allocate( nelements );
ifs.read( (char*)( m_values.data() ), file_size );
}
if ( m_big_endian != kvs::Endian::IsBig() )
{
kvs::Endian::Swap( m_values.data(), m_values.size() );
}
ifs.close();
return true;
}
/*===========================================================================*/
bool VisualizationPipeline::exec()
{
// Setup object.
if ( !this->import() )
{
kvsMessageError( "Cannot import the object." );
return false;
}
const kvs::ObjectBase* object = m_object;
ModuleList::iterator module = m_module_list.begin();
ModuleList::iterator last = m_module_list.end();
// Skip the renderer module since the renderer is executed in the display function.
if ( this->hasRenderer() ) --last;
// Execute the filter or the mapper module.
while ( module != last )
{
object = module->exec( object );
if ( !object )
{
kvsMessageError("Cannot execute '%s'.", module->name() );
return false;
}
++module;
}
// Attache the pointer to the object that is registered in the object manager.
m_object = object;
// Setup renderer.
if ( !this->hasRenderer() )
{
// create renderer module.
if ( !this->create_renderer_module( object ) )
{
kvsMessageError( "Cannot create a renderer for '%s'.", m_filename.c_str() );
return false;
}
}
// Find the renderer module.
ModuleList::iterator renderer_module = this->find_module( kvs::PipelineModule::Renderer );
if ( renderer_module != m_module_list.end() )
{
// WARNING: The renderer module is disconnected from the pipeline module
// as well as the object module.
renderer_module->disable_auto_delete();
// Attach the pointer to the renderer that is registered in the renderer manager.
m_renderer = renderer_module->renderer();
}
return true;
}
/*===========================================================================*/
bool StructuredVolumeObject::write( const std::string& filename, const bool ascii, const bool external ) const
{
kvs::KVSMLStructuredVolumeObject kvsml;
kvsml.setWritingDataType( ::GetWritingDataType( ascii, external ) );
if ( this->label() != "" ) { kvsml.setLabel( this->label() ); }
if ( this->unit() != "" ) { kvsml.setUnit( this->unit() ); }
switch ( this->gridType() )
{
case kvs::StructuredVolumeObject::UnknownGridType:
{
kvsMessageError("Unknown grid type.");
break;
}
case kvs::StructuredVolumeObject::Uniform:
{
kvsml.setGridType("uniform");
break;
}
/*
case kvs::StructuredVolumeObject::Rectilinear:
kvsml.setGridType("rectilinear");
break;
case kvs::StructuredVolumeObject::Curvilinear:
kvsml.setGridType("curvilinear");
break;
*/
default:
{
kvsMessageError("'uniform' grid type is only supported.");
break;
}
}
kvsml.setVeclen( this->veclen() );
kvsml.setResolution( this->resolution() );
kvsml.setValues( this->values() );
if ( this->hasMinMaxValues() )
{
kvsml.setMinValue( this->minValue() );
kvsml.setMaxValue( this->maxValue() );
}
if ( this->hasMinMaxObjectCoords() )
{
kvsml.setMinMaxObjectCoords( this->minObjectCoord(), this->maxObjectCoord() );
}
if ( this->hasMinMaxExternalCoords() )
{
kvsml.setMinMaxExternalCoords( this->minExternalCoord(), this->maxExternalCoord() );
}
return kvsml.write( filename );
}
/*===========================================================================*/
bool WriteColorData(
kvs::XMLNode::SuperClass* parent,
const kvs::kvsml::WritingDataType writing_type,
const std::string& filename,
const kvs::ValueArray<kvs::UInt8>& colors )
{
// <Color>
if ( colors.size() > 0 )
{
kvs::kvsml::ColorTag color_tag;
if ( !color_tag.write( parent ) )
{
kvsMessageError( "Cannot write <%s>.", color_tag.name().c_str() );
return false;
}
// <DataValue>
if ( colors.size() == 3 )
{
kvs::kvsml::DataValueTag data_tag;
if ( !data_tag.write( color_tag.node(), colors ) )
{
kvsMessageError( "Cannot write <%s> for <%s>.",
data_tag.name().c_str(),
color_tag.name().c_str() );
return false;
}
}
// <DataArray>
else
{
kvs::kvsml::DataArrayTag data_tag;
if ( writing_type == kvs::kvsml::ExternalAscii )
{
data_tag.setFile( kvs::kvsml::DataArray::GetDataFilename( filename, "color" ) );
data_tag.setFormat( "ascii" );
}
else if ( writing_type == kvs::kvsml::ExternalBinary )
{
data_tag.setFile( kvs::kvsml::DataArray::GetDataFilename( filename, "color" ) );
data_tag.setFormat( "binary" );
}
const std::string pathname = kvs::File( filename ).pathName();
if ( !data_tag.write( color_tag.node(), colors, pathname ) )
{
kvsMessageError( "Cannot write <%s> for <%s>.",
data_tag.name().c_str(),
color_tag.name().c_str() );
return false;
}
}
}
return true;
}
/*===========================================================================*/
bool WriteSizeData(
kvs::XMLNode::SuperClass* parent,
const kvs::kvsml::WritingDataType writing_type,
const std::string& filename,
const kvs::ValueArray<kvs::Real32>& sizes )
{
// <Size>
if ( sizes.size() > 0 )
{
kvs::kvsml::SizeTag size_tag;
if ( !size_tag.write( parent ) )
{
kvsMessageError( "Cannot write <%s>.", size_tag.name().c_str() );
return false;
}
// <DataValue>
if ( sizes.size() == 1 )
{
kvs::kvsml::DataValueTag data_tag;
if ( !data_tag.write( size_tag.node(), sizes ) )
{
kvsMessageError( "Cannot write <%s> for <%s>.",
data_tag.name().c_str(),
size_tag.name().c_str() );
return false;
}
}
// <DataArray>
else
{
kvs::kvsml::DataArrayTag data_tag;
if ( writing_type == kvs::kvsml::ExternalAscii )
{
data_tag.setFile( kvs::kvsml::DataArray::GetDataFilename( filename, "size" ) );
data_tag.setFormat( "ascii" );
}
else if ( writing_type == kvs::kvsml::ExternalBinary )
{
data_tag.setFile( kvs::kvsml::DataArray::GetDataFilename( filename, "size" ) );
data_tag.setFormat( "binary" );
}
const std::string pathname = kvs::File( filename ).pathName();
if ( !data_tag.write( size_tag.node(), sizes, pathname ) )
{
kvsMessageError( "Cannot write <%s> for <%s>.",
data_tag.name().c_str(),
size_tag.name().c_str() );
return false;
}
}
}
return true;
}
/*===========================================================================*/
StructuredVolumeImporter::StructuredVolumeImporter( const std::string& filename )
{
if ( kvs::KVSMLStructuredVolumeObject::CheckExtension( filename ) )
{
BaseClass::setSuccess( SuperClass::read( filename ) );
}
else if ( kvs::AVSField::CheckExtension( filename ) )
{
kvs::AVSField* file_format = new kvs::AVSField( filename );
if( !file_format )
{
BaseClass::setSuccess( false );
kvsMessageError("Cannot read '%s'.",filename.c_str());
return;
}
if( file_format->isFailure() )
{
BaseClass::setSuccess( false );
kvsMessageError("Cannot read '%s'.",filename.c_str());
delete file_format;
return;
}
this->import( file_format );
delete file_format;
}
else if ( kvs::DicomList::CheckDirectory( filename ) )
{
kvs::DicomList* file_format = new kvs::DicomList( filename );
if( !file_format )
{
BaseClass::setSuccess( false );
kvsMessageError("Cannot read '%s'.",filename.c_str());
return;
}
if( file_format->isFailure() )
{
BaseClass::setSuccess( false );
kvsMessageError("Cannot read '%s'.",filename.c_str());
delete file_format;
return;
}
this->import( file_format );
delete file_format;
}
else
{
BaseClass::setSuccess( false );
kvsMessageError("Cannot import '%s'.",filename.c_str());
return;
}
}
void FrameBufferObject::checkStatus() const
{
const GLenum status = this->checkFramebufferStatus();
if ( status == GL_FRAMEBUFFER_COMPLETE ) { return; }
switch ( status )
{
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
kvsMessageError( "Framebuffer incomplete attachement" );
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
kvsMessageError( "Framebuffer incomplete, missing attachment" );
break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
kvsMessageError( "Framebuffer incomplete, missing draw buffer" );
break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
kvsMessageError( "Framebuffer incomplete, missing read buffer" );
break;
case GL_FRAMEBUFFER_UNSUPPORTED:
kvsMessageError( "Unsupported framebuffer format" );
break;
case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE:
kvsMessageError( "Framebuffer incomplete multisample" );
break;
case GL_FRAMEBUFFER_UNDEFINED:
kvsMessageError( "Framebuffer undefined" );
break;
default:
kvsMessageError( "Unknown framebuffer error" );
break;
}
}
void BufferObject::releaseGL( const kvs::cl::CommandQueue& queue )
{
if ( !m_is_created )
{
kvsMessageError( "Buffer is not created yet." );
return;
}
const cl_int result = clEnqueueReleaseGLObjects(
queue.queue(), 1, &m_memory, 0, NULL, NULL );
if ( result != CL_SUCCESS )
{
kvsMessageError( "OpenCL; %s.", kvs::cl::ErrorString( result ) );
}
}
/*===========================================================================*/
const kvs::PolygonObject::NormalType Argument::normalType( void )
{
const kvs::PolygonObject::NormalType default_value = kvs::PolygonObject::PolygonNormal;
kvs::PolygonObject::NormalType normal_type = default_value;
if ( this->hasOption("n") )
{
const std::string option_value = this->optionValue<std::string>("n");
if ( option_value == "poly" ||
option_value == "polygon" )
{
normal_type = kvs::PolygonObject::PolygonNormal;
}
else if ( option_value == "vert" ||
option_value == "vertex" )
{
normal_type = kvs::PolygonObject::VertexNormal;
}
else
{
kvsMessageError("Unknown normal type '%s'.",option_value.c_str());
}
}
return( normal_type );
}
/*===========================================================================*/
int main( int argc, char** argv )
{
kvs::glut::Application app( argc, argv );
// Initialize capture device.
kvs::opencv::CaptureDevice device;
if ( !device.create( CV_CAP_ANY ) )
{
kvsMessageError("Capture device is NULL.");
return 1;
}
const IplImage* frame = device.queryFrame();
const size_t width = static_cast<size_t>( frame->width );
const size_t height = static_cast<size_t>( frame->height );
kvs::opencv::VideoObject* object = new kvs::opencv::VideoObject( CV_CAP_ANY );
kvs::opencv::VideoRenderer* renderer = new kvs::opencv::VideoRenderer();
kvs::glut::Screen screen( &app );
screen.setTitle( "kvs::opencv::VideoRenderer" );
screen.setSize( width, height );
screen.registerObject( object, renderer );
screen.show();
return app.run();
}
/*===========================================================================*/
void ScreenBase::create()
{
KVS_ASSERT( m_id == -1 );
// Initialize display mode.
QGLFormat f = QGLFormat::defaultFormat();
f.setDoubleBuffer( displayFormat().doubleBuffer() );
f.setRgba( displayFormat().colorBuffer() );
f.setDepth( displayFormat().depthBuffer() );
f.setAccum( displayFormat().accumulationBuffer() );
f.setStencil( displayFormat().stencilBuffer() );
f.setStereo( displayFormat().stereoBuffer() );
f.setSampleBuffers( displayFormat().multisampleBuffer() );
f.setAlpha( displayFormat().alphaChannel() );
QGLFormat::setDefaultFormat( f );
// Set screen geometry.
QWidget::setGeometry( BaseClass::x(), BaseClass::y(), BaseClass::width(), BaseClass::height() );
QGLWidget::makeCurrent();
// Initialize GLEW.
GLenum result = glewInit();
if ( result != GLEW_OK )
{
const GLubyte* message = glewGetErrorString( result );
kvsMessageError( "GLEW initialization failed: %s.", message );
}
// Create window.
static int counter = 0;
m_id = counter++;
}
/*===========================================================================*/
void ExtractEdges::calculate_connections( const kvs::UnstructuredVolumeObject* volume )
{
switch ( volume->cellType() )
{
case kvs::UnstructuredVolumeObject::Tetrahedra:
this->calculate_tetrahedra_connections( volume );
break;
case kvs::UnstructuredVolumeObject::Hexahedra:
this->calculate_hexahedra_connections( volume );
break;
case kvs::UnstructuredVolumeObject::QuadraticTetrahedra:
this->calculate_quadratic_tetrahedra_connections( volume );
break;
case kvs::UnstructuredVolumeObject::QuadraticHexahedra:
this->calculate_quadratic_hexahedra_connections( volume );
break;
case kvs::UnstructuredVolumeObject::Prism:
this->calculate_prism_connections( volume );
break;
default:
{
BaseClass::setSuccess( false );
kvsMessageError("Unknown cell type.");
break;
}
}
}
/*===========================================================================*/
void ExtractEdges::calculate_rectilinear_coords( const kvs::StructuredVolumeObject* volume )
{
kvs::IgnoreUnusedVariable( volume );
BaseClass::setSuccess( false );
kvsMessageError("Rectilinear volume has not yet supportted.");
}
/*==========================================================================*/
size_t Texture::get_channel_size( const GLenum external_type ) const
{
size_t channel_size = 0;
switch( external_type )
{
case GL_UNSIGNED_BYTE:
case GL_BYTE:
channel_size = sizeof(char);
break;
case GL_UNSIGNED_SHORT:
case GL_SHORT:
channel_size = sizeof(short);
break;
case GL_UNSIGNED_INT:
case GL_INT:
channel_size = sizeof(int);
break;
case GL_FLOAT:
channel_size = sizeof(float);
break;
default:
kvsMessageError("Unsupported OpenGL external pixel data type.");
break;
}
return channel_size;
}
/*===========================================================================*/
bool ObjectTag::write( kvs::XMLNode::SuperClass* parent )
{
kvs::XMLElement element( BaseClass::name() );
if ( m_has_type )
{
element.setAttribute( "type", m_type );
}
else
{
kvsMessageError( "'type' is not specified in <%s>.", BaseClass::name().c_str() );
return false;
}
if ( m_has_external_coord )
{
const std::string min_coord = kvs::String::ToString( m_min_external_coord );
const std::string max_coord = kvs::String::ToString( m_max_external_coord );
const std::string value = min_coord + max_coord; // is this bug? ( min_coord + " " + max_coord )
element.setAttribute( "external_coord", value );
}
if ( m_has_object_coord )
{
const std::string min_coord = kvs::String::ToString( m_min_object_coord );
const std::string max_coord = kvs::String::ToString( m_max_object_coord );
const std::string value = min_coord + max_coord; // is this bug? ( min_coord + " " + max_coord )
element.setAttribute( "object_coord", value );
}
return BaseClass::write_with_element( parent, element );
}
