void setupLightSource()
{
osg::Light * light0 = new osg::Light;
osg::Light * light1 = new osg::Light;
osg::LightSource* lightSource0 = new osg::LightSource;
osg::LightSource* lightSource1 = new osg::LightSource;
light0->setLightNum( 0 );
light0->setPosition( osg::Vec4( 5.0f, 5.0f, 10.0f, 1.0f ) );
light0->setAmbient( osg::Vec4( 0.3f, 0.3f, 0.3f, 1.0f ) );
light0->setDiffuse( osg::Vec4( 0.8f, 0.8f, 0.8f, 1.0f ) );
light0->setSpecular( osg::Vec4( 0.1f, 0.1f, 0.1f, 1.0f ) );
light0->setConstantAttenuation( 1.0f );
lightSource0->setLight( light0 );
lightSource0->setLocalStateSetModes( osg::StateAttribute::ON );
lightSource0->setStateSetModes( *(mRootNode->getOrCreateStateSet()), osg::StateAttribute::ON );
light1->setLightNum( 1 );
light1->setPosition( osg::Vec4( -5.0f, -2.0f, 10.0f, 1.0f ) );
light1->setAmbient( osg::Vec4( 0.2f, 0.2f, 0.2f, 1.0f ) );
light1->setDiffuse( osg::Vec4( 0.5f, 0.5f, 0.5f, 1.0f ) );
light1->setSpecular( osg::Vec4( 0.2f, 0.2f, 0.2f, 1.0f ) );
light1->setConstantAttenuation( 1.0f );
lightSource1->setLight( light1 );
lightSource1->setLocalStateSetModes( osg::StateAttribute::ON );
lightSource1->setStateSetModes( *(mRootNode->getOrCreateStateSet()), osg::StateAttribute::ON );
mRootNode->addChild( lightSource0 );
mRootNode->addChild( lightSource1 );
}
void Scene::onPolyhedronChanged()
{
// Update Polyhedron
auto symbol = "#" + wild::conversion_cast<std::string>(wild::mod(_index, 80) + 1);
_pgeometry->setSymbol(symbol);
_pgeometry->setFaceMask(static_cast<osgKaleido::PolyhedronGeometry::FaceMask>(_faces));
auto polyhedron = _pgeometry->getOrCreatePolyhedron();
OSG_INFO << polyhedron->getName() << " (" << polyhedron->getDualName() << "*)" << std::endl;
OSG_INFO << polyhedron->getWythoffSymbol() << std::endl;
OSG_INFO << polyhedron->getVertexConfiguration() << std::endl;
OSG_INFO << polyhedron->getVertexCount() << std::endl;
OSG_INFO << polyhedron->getFaceCount() << std::endl;
// Update Vertices
osg::ref_ptr<osg::Vec3Array> vertices = osgKaleido::createVertexArray(*polyhedron);
auto stateSet = _vgeode->getOrCreateStateSet();
auto offsets = stateSet->getUniform("offsets");
copy(offsets, vertices, osg::Vec3());
// Update Text
_text->setText(polyhedron->getName() + "\n" + polyhedron->getWythoffSymbol());
}
void processLoadedModel(osg::ref_ptr<osg::Node>& loadedModel, int optimizer_options, const std::string& cursorFileName)
{
if (!loadedModel) return;
#if !defined(OSG_GLES2_AVAILABLE) && !defined(OSG_GL3_AVAILABLE)
// add back in enabling of the GL_ALPHA_TEST to get around the core OSG no longer setting it by default for opaque bins.
// the alpha test is required for the volume rendering alpha clipping to work.
loadedModel->getOrCreateStateSet()->setMode(GL_ALPHA_TEST, osg::StateAttribute::ON);
#endif
// optimize the scene graph, remove rendundent nodes and state etc.
osgUtil::Optimizer optimizer;
optimizer.optimize(loadedModel.get(), optimizer_options);
if (!cursorFileName.empty())
{
osg::ref_ptr<osg::Group> group = new osg::Group;
group->addChild(loadedModel.get());
OSG_NOTICE<<"Creating Cursor"<<std::endl;
group->addChild(new osgPresentation::Cursor(cursorFileName, 20.0f));
loadedModel = group;
}
}
//***********************************************************
//FUNCTION:
void CPickNode::__drawCoordinateMask(const osg::Vec3f& vOrigin, float vLength, osg::ref_ptr<osg::Geode>& vMaskNode)
{
osg::ref_ptr<osg::Geometry> MakGeom = new osg::Geometry();
osg::ref_ptr<osg::Vec3Array> MaskVert = new osg::Vec3Array();
for (unsigned int i=1; i<=10; i++)
{
float Offfset = vLength / 10.0 * i;
MaskVert->push_back(osg::Vec3(vOrigin.x()+Offfset, vOrigin.y(), vOrigin.z()));
MaskVert->push_back(osg::Vec3(vOrigin.x(), vOrigin.y()+Offfset, vOrigin.z()));
MaskVert->push_back(osg::Vec3(vOrigin.x(), vOrigin.y(), vOrigin.z()+Offfset));
}
osg::ref_ptr<osg::Vec4Array> ColorArray = new osg::Vec4Array;
ColorArray->push_back(osg::Vec4(1.0, 1.0, 1.0, 1.0));
MakGeom->setVertexArray(MaskVert.get());
MakGeom->setColorArray(ColorArray);
MakGeom->setColorBinding(osg::Geometry::BIND_OVERALL);
MakGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, 30));
vMaskNode->addDrawable(MakGeom.get());
osg::ref_ptr<osg::Point> PointSize = new osg::Point(5.0);
osg::ref_ptr<osg::StateSet> PointStateSet = vMaskNode->getOrCreateStateSet();
PointStateSet->setAttribute(PointSize);
}
void myModel::setBlending()
{
_blendFunc = new osg::BlendFunc;
_stateset = _model->getOrCreateStateSet();
_blendFunc->setFunction(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
_stateset->setAttributeAndModes( _blendFunc );
}
//***********************************************************
//FUNCTION:
void CPickNode::__drawCoordinateLine(const osg::Vec3f& vOrigin, float vLength, osg::ref_ptr<osg::Geode>& vLineNode)
{
osg::ref_ptr<osg::Geometry> CoordGeometry = new osg::Geometry();
osg::ref_ptr<osg::Vec3Array> CoordVertex = new osg::Vec3Array();
CoordVertex->push_back(vOrigin);
CoordVertex->push_back(osg::Vec3(vOrigin.x()+vLength, vOrigin.y(), vOrigin.z()));
CoordVertex->push_back(vOrigin);
CoordVertex->push_back(osg::Vec3(vOrigin.x(), vOrigin.y()+vLength, vOrigin.z()));
CoordVertex->push_back(vOrigin);
CoordVertex->push_back(osg::Vec3(vOrigin.x(), vOrigin.y(), vOrigin.z()+vLength));
CoordGeometry->setVertexArray(CoordVertex.get());
CoordGeometry->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINES, 0, 6));
osg::ref_ptr<osg::Vec4Array> VertColor = new osg::Vec4Array();
VertColor->push_back(osg::Vec4(1.0, 0.0, 0.0, 1.0));
VertColor->push_back(osg::Vec4(1.0, 0.0, 0.0, 1.0));
VertColor->push_back(osg::Vec4(0.0, 1.0, 0.0, 1.0));
VertColor->push_back(osg::Vec4(0.0, 1.0, 0.0, 1.0));
VertColor->push_back(osg::Vec4(0.0, 0.0, 1.0, 1.0));
VertColor->push_back(osg::Vec4(0.0, 0.0, 1.0, 1.0));
CoordGeometry->setColorArray(VertColor.get());
CoordGeometry->setColorBinding(osg::Geometry::BIND_PER_VERTEX);
osg::ref_ptr<osg::LineWidth> LineSize = new osg::LineWidth();
LineSize->setWidth(5);
vLineNode->getOrCreateStateSet()->setAttributeAndModes(LineSize.get(), osg::StateAttribute::ON);
vLineNode->addDrawable(CoordGeometry.get());
}
void Scene::onLightModelChanged()
{
auto program = _twoSided ? _twoSidedProgram : _oneSidedProgram;
auto stateSet = _pgeode->getOrCreateStateSet();
stateSet->setAttributeAndModes(program, osg::StateAttribute::ON);
}
osg::ref_ptr<osg::Geode> Sokoban::NodeFactory::setTexture(osg::ref_ptr<osg::Geode> geode, Sokoban::Type type, std::string& texturePath) {
// create a simple material
osg::Material *material = new osg::Material();
if (isAButton(type))
material->setEmission(osg::Material::FRONT, BUTTON_EMISSION);
else
material->setEmission(osg::Material::FRONT, OBJECT_EMISSION);
// create a texture
// load image for texture
osg::ref_ptr<osg::Image> image = osgDB::readImageFile(texturePath);
if (!image) {
std::cerr << "Couldn't load texture : " << texturePath <<std::endl;
return NULL;
}
//Create the texture putting the correct option and set the image
osg::ref_ptr<osg::Texture2D> texture = new osg::Texture2D;
texture->setDataVariance(osg::Object::DYNAMIC);
texture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR_MIPMAP_LINEAR);
texture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
texture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP);
texture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP);
texture->setImage(image);
// assign the material and texture to the Geode
osg::ref_ptr<osg::StateSet> stateSet = geode->getOrCreateStateSet();
stateSet->setAttribute(material);
stateSet->setMode(GL_LIGHTING,osg::StateAttribute::ON);
stateSet->setTextureAttributeAndModes(0, texture, osg::StateAttribute::ON);
return geode;
}
void CSVRender::Object::setupCommonMarkerState(osg::ref_ptr<osg::Geometry> geometry)
{
osg::ref_ptr<osg::StateSet> state = geometry->getOrCreateStateSet();
state->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
state->setMode(GL_BLEND, osg::StateAttribute::ON);
state->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
}
void myModel::setMaterial()
{
_nodess = _model->getOrCreateStateSet();
_nodeMaterial = new osg::Material;
_nodeMaterial->setDiffuse( osg::Material::FRONT, osg::Vec4(0.5f,0.5f,0.5f,1.0f));
_nodeMaterial->setAmbient( osg::Material::FRONT, osg::Vec4(2.0f,0.0f,0.0f,1.0f) );
_nodeMaterial->setTransparency(osg::Material::FRONT , 0.25f);
_nodess->setAttribute( _nodeMaterial.get() );
}
void Scene::createVertexNode()
{
_vgeode = new osg::Geode;
_vgeode->setDataVariance(osg::Object::DYNAMIC);
osg::Vec3f lightDir(1.0f, 1.0f, 1.0f);
lightDir.normalize();
auto offsets = new osg::Uniform(osg::Uniform::FLOAT_VEC3, "offsets", Scene::VertexInstances);
offsets->setDataVariance(osg::Object::DYNAMIC);
auto stateSet = _vgeode->getOrCreateStateSet();
stateSet->setAttributeAndModes(_instancedProgram, osg::StateAttribute::ON);
stateSet->addUniform(new osg::Uniform("ecLightDirection", lightDir));
stateSet->addUniform(new osg::Uniform("lightColor", osg::Vec3(1.0f, 1.0f, 1.0f)));
stateSet->addUniform(offsets);
osg::Vec3 scale(1.0f, 1.0f, 1.0f);
osg::Vec4 color(0.25f, 0.25f, 0.25f, 1.0f);
auto vertexMatrix = osg::Matrixf::scale(scale * 0.125f * 0.25f);
auto normalMatrix = inverseTranspose(vertexMatrix);
_vgeometry = new osgKaleido::PolyhedronGeometry("#27");
_vgeometry->setUseDisplayList(false);
_vgeometry->setUseVertexBufferObjects(true);
_vgeometry->update(nullptr); // Force geometry generation
auto vertices = dynamic_cast<osg::Vec3Array*>(_vgeometry->getVertexArray());
if (vertices != nullptr) {
transform(*vertices, vertexMatrix);
}
auto normals = dynamic_cast<osg::Vec3Array*>(_vgeometry->getNormalArray());
if (normals != nullptr) {
transform(*normals, normalMatrix);
}
auto colors = dynamic_cast<osg::Vec4Array*>(_vgeometry->getColorArray());
if (colors != nullptr) {
fill(*colors, color);
}
makeInstanced(_vgeometry, Scene::VertexInstances);
auto size = 1.0f;
osg::BoundingBox bb(-size, -size, -size, +size, +size, +size);
_vgeometry->setInitialBound(bb);
_vgeode->addDrawable(_vgeometry);
addChild(_vgeode);
}
void myPostSyncPreDrawFun()
{
gEngine->setWireframe(wireframe.getVal());
gEngine->setDisplayInfoVisibility(info.getVal());
gEngine->setStatsGraphVisibility(stats.getVal());
if( takeScreenshot.getVal() )
{
gEngine->takeScreenshot();
takeScreenshot.setVal(false);
}
light.getVal() ? mRootNode->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::ON | osg::StateAttribute::OVERRIDE) :
mRootNode->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE);
mSceneTrans->setMatrix(osg::Matrix::rotate( glm::radians(curr_time.getVal() * 8.0), 0.0, 1.0, 0.0));
mSceneTrans->postMult(osg::Matrix::translate(0.0, -0.1, dist.getVal()));
//transform to scene transformation from configuration file
mSceneTrans->postMult( osg::Matrix( glm::value_ptr( gEngine->getModelMatrix() ) ));
//update the frame stamp in the viewer to sync all
//time based events in osg
mFrameStamp->setFrameNumber( gEngine->getCurrentFrameNumber() );
mFrameStamp->setReferenceTime( curr_time.getVal() );
mFrameStamp->setSimulationTime( curr_time.getVal() );
mViewer->setFrameStamp( mFrameStamp.get() );
mViewer->advance( curr_time.getVal() ); //update
//traverse if there are any tasks to do
if (!mViewer->done())
{
mViewer->eventTraversal();
//update travelsal needed for pagelod object like terrain data etc.
mViewer->updateTraversal();
}
}
bool ossimPlanetViewer::AddHudOverlay(osg::ref_ptr<osg::Node> hudNode)
{
bool result = false;
if(thePlanet.valid())
{
result = true;
hudNode->getOrCreateStateSet()->setRenderBinDetails(11,"RenderBin");
theHudOverlayList.push_back(hudNode.get());
thePlanet->addChild(hudNode.get());
}
return result;
}
void Scene::createPolyhedronNode()
{
_pgeode = new osg::Geode;
_pgeode->setDataVariance(osg::Object::DYNAMIC);
osg::Vec3f lightDir(0.0f, 0.0f, 1.0f);
lightDir.normalize();
auto stateSet = _pgeode->getOrCreateStateSet();
stateSet->setAttributeAndModes(_twoSidedProgram, osg::StateAttribute::ON);
stateSet->addUniform(new osg::Uniform("ecLightDirection", lightDir));
stateSet->addUniform(new osg::Uniform("lightColor", osg::Vec3(1.0f, 1.0f, 1.0f)));
_pgeometry = new osgKaleido::PolyhedronGeometry("#27");
_pgeometry->setUseDisplayList(false);
_pgeometry->setUseVertexBufferObjects(true);
_pgeode->addDrawable(_pgeometry);
addChild(_pgeode);
}
void BranchXML::SetupAlfaFunc( osg::ref_ptr< osg::Geode > geode , int iLOD )
{
//настроить альфа канал
//получить ссылку на данные ствола
dataBranch &_data = xmlRoot::Instance().GetDataBranch();
if ( _data.m_vLOD[ iLOD ].m_fAlphaTestValue > 0.0f)
{
//настройка атрибутов состояния LOD ствола
osg::StateSet* state = geode->getOrCreateStateSet();
//помечаем объект как имеющий прозрачность
state->setRenderingHint( osg::StateSet::TRANSPARENT_BIN );
// Turn on alpha testing
osg::AlphaFunc* af = new osg::AlphaFunc(
osg::AlphaFunc::GREATER, _data.m_vLOD[ iLOD ].m_fAlphaTestValue );
state->setAttributeAndModes( af );
}
}
osg::Camera* createDebugText()
{
return 0;
//////////////////////////
// debug text
//////////////////////////
// create text and add it to our geometry node
rTextCam = new osgText::Text;
rTextCam->setFont("tempest.ttf");
osg::Geode* pGeodeText = new osg::Geode;
pGeodeText->addDrawable( rTextCam );
// create an ortho projection so our text is screen aligned
osg::Camera* camera = new osg::Camera;
camera->setProjectionMatrix( osg::Matrix::ortho2D(0,800,0,600) );
camera->setViewMatrix(osg::Matrix::identity());
camera->setReferenceFrame( osg::Transform::ABSOLUTE_RF );
camera->setViewMatrix( osg::Matrix::identity() );
camera->setAllowEventFocus(false);
camera->setClearMask(GL_DEPTH_BUFFER_BIT);
camera->setRenderOrder(osg::Camera::POST_RENDER);
camera->addChild( pGeodeText );
// set some text data
rTextCam->setPosition( osg::Vec3( 10.f, 400.0f, 0.0f ) );
rTextCam->setColor( osg::Vec4( 1.0f, 1.0f, 0.0f, 1.0f ) );
rTextCam->setText( "Hello World" );
rTextCam->setDataVariance( osg::Object::DYNAMIC );
rTextCam->getOrCreateStateSet()->setMode( GL_LIGHTING, osg::StateAttribute::OFF );
return camera;
}
void ComputeNode::addComputationResultsRenderTree()
{
_computationResultsRenderProgram = new osg::Program;
_vertexShader = osgDB::readRefShaderFile(osg::Shader::VERTEX, _vertexShaderSourcePath);
_computationResultsRenderProgram->addShader(_vertexShader.get());
_geometryShader = osgDB::readRefShaderFile(osg::Shader::GEOMETRY, _geometryShaderSourcePath);
_computationResultsRenderProgram->addShader(_geometryShader.get());
_fragmentShader = osgDB::readRefShaderFile(osg::Shader::FRAGMENT, _fragmentShaderSourcePath);
_computationResultsRenderProgram->addShader(_fragmentShader.get());
_computationResultsRenderProgram->addBindAttribLocation("tex_coords", 1);
_computationResultsRenderGroup = new osg::Group;
_computationResultsRenderGroup->setDataVariance(osg::Object::DYNAMIC);
_computationResultsRenderStateSet = _computationResultsRenderGroup->getOrCreateStateSet();
_computationResultsRenderStateSet->setRenderingHint(osg::StateSet::TRANSPARENT_BIN);
osg::PointSprite *sprite = new osg::PointSprite;
int texture_unit = 0;
_computationResultsRenderStateSet->setTextureAttributeAndModes(texture_unit, sprite, osg::StateAttribute::ON);
_computationResultsRenderStateSet->setAttributeAndModes(_computationResultsRenderProgram.get(), osg::StateAttribute::ON);
_computationResultsRenderStateSet->addUniform(new osg::Uniform("particleTexture", texture_unit));
_computationResultsRenderStateSet->addUniform(new osg::Uniform("numRows", (int)NUM_ELEMENTS_X));
_computationResultsRenderStateSet->addUniform(new osg::Uniform("numCols", (int)NUM_ELEMENTS_Y));
_computationResultsRenderStateSet->setMode(GL_POINT_SMOOTH, osg::StateAttribute::ON);
_computationResultsRenderStateSet->setMode(GL_VERTEX_PROGRAM_POINT_SIZE_ARB, osg::StateAttribute::ON);
_computationResultsRenderStateSet->setMode(GL_ALPHA_TEST, osg::StateAttribute::ON);
_computationResultsRenderStateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
osg::Texture2D *tex = new osg::Texture2D();
osg::Image* particleImage = createSpotLightImage(osg::Vec4(1, 0, 0, 1), osg::Vec4(0.5, 0, 0, 0.0), 32, 0.7);
if (particleImage)
{
tex->setImage(particleImage);
}
_computationResultsRenderStateSet->setTextureAttributeAndModes(texture_unit, tex, osg::StateAttribute::ON);
osg::BlendFunc *blend = new osg::BlendFunc;
if (false) //emissive particles
{
blend->setFunction(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE);
}
else
{
blend->setFunction(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE_MINUS_SRC_ALPHA);
}
_computationResultsRenderStateSet->setAttributeAndModes(blend, osg::StateAttribute::ON);
osg::Depth* depth = new osg::Depth;
depth->setRange(0.0f, 0.0f);
depth->setFunction(osg::Depth::ALWAYS);
depth->setWriteMask(false);
depth->setFunction(osg::Depth::ALWAYS);
_computationResultsRenderStateSet->setAttributeAndModes(depth, osg::StateAttribute::OFF);
osg::Geode* particleGeode = new osg::Geode;
unsigned int numVertices = NUM_ELEMENTS_X*NUM_ELEMENTS_Y;
osg::Geometry* particleGeometry = new osg::Geometry;
particleGeometry->setUseDisplayList(false);
particleGeometry->setUseVertexBufferObjects(true);
osg::Vec3Array* vertexarray = new osg::Vec3Array;
osg::Vec2Array* tcoords = new osg::Vec2Array;
osg::Vec2 bottom_texcoord(0.0f, 0.0f);
osg::Vec2 dx_texcoord(1.0f / (float)(NUM_ELEMENTS_X), 0.0f);
osg::Vec2 dy_texcoord(0.0f, 1.0f / (float)(NUM_ELEMENTS_Y));
for (int i = 0; i < NUM_ELEMENTS_X; i++)
{
osg::Vec2 texcoord = bottom_texcoord + dy_texcoord*(float)i;
for (int j = 0; j < NUM_ELEMENTS_Y; j++)
{
vertexarray->push_back(osg::Vec3(texcoord.x(), texcoord.y(), 0.0));
tcoords->push_back(osg::Vec2(texcoord.x(), texcoord.y()));
texcoord += dx_texcoord;
}
}
particleGeometry->setVertexArray(vertexarray);
particleGeometry->addPrimitiveSet(new osg::DrawArrays(GL_POINTS, 0, numVertices));
particleGeometry->setTexCoordArray(0, tcoords);
//this glMemoryBarrier thing... not sure if we could better do instanced drawing? all the data is in Shader Storage Buffer..
particleGeometry->setVertexAttribArray(1, particleGeometry->getTexCoordArray(0), osg::Array::BIND_PER_VERTEX);
_computationResultsRenderGroup->addChild(particleGeode);
particleGeode->addDrawable(particleGeometry);
addChild(_computationResultsRenderGroup.get());
}
int main( int argc, char **argv )
{
if(argc<4) {
usage(argc,argv);
return 1;
}
is = helper::createImageSource(argv[1]);
if(is.empty() || is->done()) {
loglne("[main] createImageSource failed or no valid imagesource!");
return -1;
}
is->pause(false);
is->reportInfo();
is->get(frame);
imgW = frame.cols; imgH = frame.rows;
videoFromWebcam = false;
if( is->classname() == "ImageSource_Camera" ) {
videoFromWebcam = true;
}
loglni("[main] loading K matrix from: "<<argv[2]);
double K[9];
std::ifstream kfile(argv[2]);
for(int i=0; i<9; ++i) kfile >> K[i];
tracker.loadK(K);
loglni("[main] K matrix loaded:");
loglni(helper::PrintMat<>(3,3,K));
loglni("[main] load template image from: "<<argv[3]);
tracker.loadTemplate(argv[3]);
//////////////// TagDetector /////////////////////////////////////////
int tagid = 0; //default tag16h5
if(argc>5) tagid = atoi(argv[5]);
tagFamily = TagFamilyFactory::create(tagid);
if(tagFamily.empty()) {
loglne("[main] create TagFamily fail!");
return -1;
}
detector = new TagDetector(tagFamily);
if(detector.empty()) {
loglne("[main] create TagDetector fail!");
return -1;
}
Mat temp = imread(argv[3]);
if( findAprilTag(temp, 0, HI, true) ) {
namedWindow("template");
imshow("template", temp);
iHI = HI.inv();
} else {
loglne("[main error] detector did not find any apriltag on template image!");
return -1;
}
//////////////// OSG ////////////////////////////////////////////////
osg::ref_ptr<osg::Group> root = new osg::Group;
string scenefilename = (argc>4?argv[4]:("cow.osg"));
osg::ref_ptr<osg::Node> cow = osgDB::readNodeFile(scenefilename);
arscene = new helper::ARSceneRoot;
helper::FixMat<3,double>::Type matK = helper::FixMat<3,double>::ConvertType(K);
CV2CG::cv2cg(matK,0.01,500,imgW,imgH,*arscene);
manipMat = new osg::MatrixTransform(osg::Matrix::identity());
manipMat->addChild(cow);
manipMat->getOrCreateStateSet()->setMode(GL_NORMALIZE, osg::StateAttribute::ON);
arscene->addChild(manipMat);
osg::ref_ptr<osg::Image> backgroundImage = new osg::Image;
helper::cvmat2osgimage(frame,backgroundImage);
arvideo = new helper::ARVideoBackground(backgroundImage);
root->setUpdateCallback(new ARUpdateCallback);
root->addChild(arvideo);
root->addChild(arscene);
viewer.setSceneData(root);
viewer.addEventHandler(new osgViewer::StatsHandler);
viewer.addEventHandler(new osgViewer::WindowSizeHandler);
viewer.addEventHandler(new QuitHandler);
//start tracking thread
OpenThreads::Thread::Init();
TrackThread* thr = new TrackThread;
thr->start();
viewer.run();
delete thr;
loglni("[main] DONE...exit!");
return 0;
}