// The initialisation function
__declspec(dllexport) void alvar_init(int width, int height)
{
w = width;
h = height;
// Calibration. See manual and ALVAR internal samples how to calibrate your camera
// Calibration will make the marker detecting and marker pose calculation more accurate.
if (! camera.SetCalib("Calibrations/default_calib.xml", w, h)) {
camera.SetRes(w, h);
}
// Set projection matrix as ALVAR recommends (based on the camera calibration)
double p[16];
camera.GetOpenglProjectionMatrix(p, w, h);
//Initialize the multimarker system
for(int i = 0; i < MARKER_COUNT; ++i)
markerIdVector.push_back(i);
// We make the initialization for MultiMarkerBundle using a fixed marker field (can be printed from MultiMarker.ppt)
markerDetector.SetMarkerSize(CORNER_MARKER_SIZE);
markerDetector.SetMarkerSizeForId(0, CENTRE_MARKER_SIZE);
multiMarker = new alvar::MultiMarker(markerIdVector);
alvar::Pose pose;
pose.Reset();
// Add the 5 markers
multiMarker->PointCloudAdd(0, CENTRE_MARKER_SIZE, pose);
pose.SetTranslation(-10, 6, 0);
multiMarker->PointCloudAdd(1, CORNER_MARKER_SIZE, pose);
pose.SetTranslation(10, 6, 0);
multiMarker->PointCloudAdd(2, CORNER_MARKER_SIZE, pose);
pose.SetTranslation(-10, -6, 0);
multiMarker->PointCloudAdd(3, CORNER_MARKER_SIZE, pose);
pose.SetTranslation(+10, -6, 0);
multiMarker->PointCloudAdd(4, CORNER_MARKER_SIZE, pose);
trackerStat.Reset();
}
/**
* @function init
* @brief Initialize required parameters
*/
bool init( int _devIndex,
int _camIndex,
alvar::Capture **_cap ) {
std::cout << "Reading /dev/video"<<_devIndex<<" and camera "<<_camIndex<< std::endl;
gCalibFilename = CAM_CALIB_NAME[_camIndex];
/** Load calibration file */
std::cout<<"** Loading calibration file: "<< gCalibFilename << std::endl;
if ( gCam.SetCalib( gCalibFilename.c_str(),
gWidth, gHeight) ) {
std::cout<<"\t Loaded camera calibration file successfully"<<std::endl;
} else {
gCam.SetRes( gWidth, gHeight );
std::cout<<"\t Failed to load camera calibration file"<<std::endl;
}
/** Set camera matrix into the viewer */
double p[16];
gCam.GetOpenglProjectionMatrix( p,
gWidth,
gHeight );
GlutViewer::SetGlProjectionMatrix(p);
for (int i=0; i<32; i++) {
d[i].SetScale( gMarker_size);
}
std::cout << "\t * Set Viewer with camera matrix"<<std::endl;
/** Create capture object from camera */
/*-- Enumerate possible capture plugins --*/
alvar::CaptureFactory::CapturePluginVector plugins = alvar::CaptureFactory::instance()->enumeratePlugins();
if (plugins.size() < 1) {
std::cout << "\t Could not find any capture plugins." << std::endl;
return 0;
}
/*-- Display capture plugins --*/
std::cout << "Available Plugins: ";
outputEnumeratedPlugins(plugins);
std::cout << std::endl;
/*-- Enumerate possible capture devices --*/
alvar::CaptureFactory::CaptureDeviceVector devices = alvar::CaptureFactory::instance()->enumerateDevices();
if (devices.size() < 1) {
std::cout << "\t [X] Could not find any capture devices." << std::endl;
return 0;
}
/*-- Check if _devIndex can be used --*/
int selectedDevice;
if( _devIndex > devices.size() ) {
std::cout << "Device index /dev/video"<<_devIndex<<" bigger than the size of devices vector." << std::endl;
return false;
}
selectedDevice = _devIndex;
/**- Display capture devices (DEBUG) --*/
std::cout << "Enumerated Capture Devices:" << std::endl;
outputEnumeratedDevices(devices, selectedDevice);
std::cout << std::endl;
/*-- Create capture object from camera --*/
*_cap = CaptureFactory::instance()->createCapture( devices[selectedDevice] );
return true;
}
// main
int main(int argc, char** argv)
{
osg::ArgumentParser arguments(&argc, argv);
// Let's use the convenience system from ALVAR for capturing.
// We initialize Highgui through the CaptureFactory (see manual for other options like AVI)
alvar::CaptureFactory *factory = alvar::CaptureFactory::instance();
alvar::CaptureFactory::CaptureDeviceVector devices = factory->enumerateDevices("highgui");
// Check to ensure that a device was found
if (devices.size() > 0) {
capture = factory->createCapture(devices.front());
}
// Capture is central feature, so if we fail, we get out of here.
if (capture && capture->start()) {
// Let's capture one frame to get video resolution
IplImage *tempImg = capture->captureImage();
videoXRes = tempImg->width;
videoYRes = tempImg->height;
// Calibration. See manual and ALVAR internal samples how to calibrate your camera
// Calibration will make the marker detecting and marker pose calculation more accurate.
if (! camera.SetCalib("calib.xml", videoXRes, videoYRes)) {
camera.SetRes(videoXRes, videoYRes);
}
//Create the osg::Image for the video
videoImage = new osg::Image;
//Create the osg::Image for the texture (marker hiding)
texImage = new osg::Image;
//IplImage for the texture generation.
markerHiderImage=cvCreateImage(cvSize(64, 64), 8, 4);
// construct the viewer
viewer = new osgViewer::Viewer(arguments);
// Let's use window size of the video (approximate).
viewer->setUpViewInWindow (200, 200, videoXRes, videoYRes);
// Viewport is the same
viewer->getCamera()->setViewport(0,0,videoXRes,videoYRes);
viewer->setLightingMode(osg::View::HEADLIGHT);
// Attach our own event handler to the system so we can catch the resizing events
viewer->addEventHandler(new CSimpleWndSizeHandler(videoXRes,videoYRes ));
// Set projection matrix as ALVAR recommends (based on the camera calibration)
double p[16];
camera.GetOpenglProjectionMatrix(p,videoXRes,videoYRes);
viewer->getCamera()->setProjectionMatrix(osg::Matrix(p));
// Create main root for everything
arRoot = new osg::Group;
arRoot->setName("ALVAR stuff (c) VTT");
// Init the video background class and add it to the graph
videoBG.Init(videoXRes,videoYRes,(tempImg->origin?true:false));
arRoot->addChild(videoBG.GetOSGGroup());
// Create model switch and add it the to graph
modelSwitch = new osg::Switch;
arRoot->addChild(modelSwitch.get());
// Create model transformation for the markers and add them under the switch
mtForMarkerFive = new osg::MatrixTransform;
mtForMarkerTen = new osg::MatrixTransform;
modelSwitch->addChild(mtForMarkerFive.get());
modelSwitch->addChild(mtForMarkerTen.get());
// add the texture under the marker transformation node
mtForMarkerFive->addChild(texOnMarker.GetDrawable());
// All models off
modelSwitch->setAllChildrenOff();
// load the data (models).
modelForMarkerFive = osgDB::readNodeFile("grid.osg");
modelForMarkerTen = osgDB::readNodeFile("axes.osg");
// If loading ok, add models under the matrixtransformation nodes.
if(modelForMarkerFive)
mtForMarkerFive->addChild(modelForMarkerFive.get());
if(modelForMarkerTen)
mtForMarkerTen->addChild(modelForMarkerTen.get());
// Tell the ALVAR the markers' size (same to all)
// You can also specify different size for each individual markers
markerDetector.SetMarkerSize(MARKER_SIZE);
// Set scene data
viewer->setSceneData(arRoot.get());
// And start the main loop
while(!viewer->done()){
//Call the rendering function over and over again.
renderer();
}
}
// Time to close the system
if(capture){
capture->stop();
delete capture;
}
if(markerHiderImage)
cvReleaseImage(&markerHiderImage);
return 0; // bye bye. Happy coding!
}
/*
Initialize OSG, create a Viewer
*/
bool InitOSG(int w, int h, bool flip_image, std::string model_file, std::string camera_file)
{
int offx = 10;
int offy = 30;
viewer = new osgViewer::Viewer;
osg::GraphicsContext::WindowingSystemInterface* wsi = osg::GraphicsContext::getWindowingSystemInterface();
if (!wsi)
{
osg::notify(osg::NOTICE) << "Error, no WindowSystemInterface available, cannot create windows." << std::endl;
return false;
}
unsigned int width, height;
wsi->getScreenResolution(osg::GraphicsContext::ScreenIdentifier(0), width, height);
osg::ref_ptr<osg::GraphicsContext::Traits> traits = new osg::GraphicsContext::Traits;
traits->x = offx;
traits->y = offy;
traits->width = w;
traits->height = h;
traits->windowDecoration = true;
traits->doubleBuffer = true;
traits->sharedContext = 0;
osg::ref_ptr<osg::GraphicsContext> gc = osg::GraphicsContext::createGraphicsContext(traits.get());
if (gc.valid())
{
osg::notify(osg::INFO) << " GraphicsWindow has been created successfully." << std::endl;
// need to ensure that the window is cleared make sure that the complete window is set the correct colour
// rather than just the parts of the window that are under the camera's viewports
gc->setClearColor(osg::Vec4f(0.2f,0.2f,0.6f,1.0f));
gc->setClearMask(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
else
{
osg::notify(osg::NOTICE) << " GraphicsWindow has not been created successfully." << std::endl;
}
model_node = osgDB::readNodeFile(model_file.c_str());
model_transform = new osg::MatrixTransform;
model_transform->addChild(model_node.get());
model_switch = new osg::Switch;
model_switch->addChild(model_transform.get());
model_switch->setAllChildrenOff();
root_group = new osg::Group;
root_group->addChild(model_switch.get());
osg::StateSet *state_set = new osg::StateSet;
state_set->setMode(GL_LIGHTING, osg::StateAttribute::OFF | osg::StateAttribute::OVERRIDE);
model_node->setStateSet(state_set);
root_group->setStateSet(state_set);
viewer->getCamera()->setViewport(new osg::Viewport(0, 0, w, h));
viewer->getCamera()->setGraphicsContext(gc.get());
viewer->addEventHandler(new PickHandler());
viewer->setThreadingModel(osgViewer::Viewer::SingleThreaded);
viewBG = new ViewWithBackGroundImage(viewer, w, h, flip_image, root_group);
cam.SetCalib(camera_file.c_str(), w, h);
double p[16];
cam.GetOpenglProjectionMatrix(p, w, h);
viewer->getCamera()->setProjectionMatrix(osg::Matrix(p));
return true;
}
