int main( int argc, char** argv ){
#if (CISST_OS == CISST_LINUX_XENOMAI)
// Xenomai stuff
mlockall(MCL_CURRENT | MCL_FUTURE);
RT_TASK task;
rt_task_shadow( &task, "CANServer", 80, 0);
#endif
cmnLogger::SetMask( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskFunction( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskDefaultLog( CMN_LOG_ALLOW_ALL );
if( argc !=2 ){
std::cerr << "Usage: " << argv[0] << " can[?]" << std::endl;
return -1;
}
// Better to have the CAN device in loopback mode
std::cout << "Ensure that the CAN device is in loopback mode" << std::endl;
// get local component manager
mtsManagerLocal *taskManager;
taskManager = mtsManagerLocal::GetInstance();
// The RTSocketCAN component
#if (CISST_OS == CISST_LINUX_XENOMAI)
mtsRTSocketCAN can( "CAN",
argv[1],
osaCANBus::RATE_1000,
osaCANBus::LOOPBACK_ON );
#else
mtsSocketCAN can( "CAN",
argv[1],
osaCANBus::RATE_1000,
osaCANBus::LOOPBACK_ON );
#endif
taskManager->AddComponent( &can );
// A client
CANclient client;
taskManager->AddComponent( &client );
// Connect the interfaces
taskManager->Connect( client.GetName(), "IO", can.GetName(), "IO" );
taskManager->Connect( client.GetName(), "CTL", can.GetName(), "CTL" );
taskManager->CreateAll();
taskManager->StartAll();
// Wait to exit
std::cout << "ENTER to exit" << std::endl;
cmnGetChar();
//taskManager->KillAll();
//taskManager->Cleanup();
return 0;
}
int main( int argc, char** argv ){
mtsTaskManager* taskManager = mtsTaskManager::GetInstance();
cmnLogger::SetMask( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskFunction( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskDefaultLog( CMN_LOG_ALLOW_ALL );
if( argc != 2 ){
std::cout << "Usage: " << argv[0] << " can[0-1]" << std::endl;
return -1;
}
osaSocketCAN can( argv[1], osaCANBus::RATE_1000 );
if( can.Open() != osaCANBus::ESUCCESS ){
CMN_LOG_RUN_ERROR << argv[0] << "Failed to open " << argv[1] << std::endl;
return -1;
}
mtsWAM WAM( "WAM", &can, osaWAM::WAM_7DOF, OSA_CPU4, 80 );
WAM.Configure();
WAM.SetPositions( vctDynamicVector<double>(7,
0.0, -cmnPI_2, 0.0, cmnPI,
0.0, 0.0, 0.0 ) );
taskManager->AddComponent( &WAM );
WAMprobe probe;
taskManager->AddComponent( &probe );
taskManager->Connect( probe.GetName(), "Input", WAM.GetName(), "Output" );
taskManager->Connect( probe.GetName(), "Output", WAM.GetName(), "Input" );
taskManager->CreateAll();
taskManager->WaitForStateAll( mtsComponentState::READY );
taskManager->StartAll();
taskManager->WaitForStateAll( mtsComponentState::ACTIVE );
std::cout << "ENTER to exit" << std::endl;
cmnGetChar();
taskManager->KillAll();
taskManager->Cleanup();
if( can.Close() != osaCANBus::ESUCCESS ){
CMN_LOG_RUN_ERROR << argv[0] << "Failed to open " << argv[1] << std::endl;
return -1;
}
return 0;
}
int svlVideoCodecTCPStream::DialogCompression()
{
if (Opened) return SVL_FAIL;
std::string extension;
std::cout << " # Enable lossy (JPEG) compression ('y' or other): ";
int ival = cmnGetChar();
if (ival == 'y' || ival == 'Y') {
std::cout << "YES" << std::endl;
return DialogCompression(".njpg");
}
std::cout << "NO" << std::endl;
return DialogCompression(".ncvi");
}
int main( int argc, char** argv ){
mlockall(MCL_CURRENT | MCL_FUTURE);
RT_TASK task;
rt_task_shadow( &task, "GroupTest", 99, 0 );
cmnLogger::SetMask( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskFunction( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskDefaultLog( CMN_LOG_ALLOW_ALL );
if( argc != 2 ){
std::cout << "Usage: " << argv[0] << " rtcan[0-1]" << std::endl;
return -1;
}
osaRTSocketCAN can( argv[1], osaCANBus::RATE_1000 );
if( can.Open() != osaCANBus::ESUCCESS ){
std::cerr << argv[0] << "Failed to open " << argv[1] << std::endl;
return -1;
}
osaBH8_280 BH( &can );
if( BH.Initialize() != osaBH8_280::ESUCCESS ){
std::cerr << "Failed to initialize WAM" << std::endl;
return -1;
}
std::cout << "\n\n\n\n";
double t1 = osaGetTime();
size_t cnt=0;
while( 1 ){
Eigen::VectorXd q( 4, 0.1 );
BH.GetPositions( q );
//BH.SetPositions( q );
}
cmnGetChar();
return 0;
}
int main( int argc, char** argv ){
cmnLogger::SetMask( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskFunction( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskDefaultLog( CMN_LOG_ALLOW_ALL );
if( argc != 2 ){
std::cout << "Usage: " << argv[0] << " can[0-1]" << std::endl;
return -1;
}
osaSocketCAN can( argv[1], osaCANBus::RATE_1000 );
if( can.Open() != osaCANBus::ESUCCESS ){
CMN_LOG_RUN_ERROR << argv[0] << "Failed to open " << argv[1] << std::endl;
return -1;
}
osaBH8_280 BH( &can );
if( BH.Initialize() != osaBH8_280::ESUCCESS ){
CMN_LOG_RUN_ERROR << "Failed to initialize WAM" << std::endl;
return -1;
}
std::cout << "\n\n\n\n";
double t1 = osaGetTime();
size_t cnt=0;
while( 1 ){
vctDynamicVector<double> q( 4, 0.1 );
BH.GetPositions( q );
//BH.SetPositions( q );
}
cmnGetChar();
return 0;
}
int main(){
mtsTaskManager* taskManager = mtsTaskManager::GetInstance();
cmnLogger::SetMask( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskFunction( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskDefaultLog( CMN_LOG_ALLOW_ALL );
osg::ref_ptr< osaOSGWorld > world = new osaOSGWorld;
// Create a camera
int x = 0, y = 0;
int width = 320, height = 240;
double Znear = 0.1, Zfar = 10.0;
mtsOSGMono* camera;
camera = new mtsOSGMono( "camera",
world,
x, y,
width, height,
55.0, ((double)width)/((double)height),
Znear, Zfar,
false );
taskManager->AddComponent( camera );
// create the camera motion
CameraMotion cmotion;
taskManager->AddComponent( &cmotion );
// create the hubble motion
HubbleMotion hmotion;
taskManager->AddComponent( &hmotion );
cmnPath path;
path.AddRelativeToCisstShare("/models");
path.AddRelativeToCisstShare("/models/hubble");
vctFrame4x4<double> Rt( vctMatrixRotation3<double>(),
vctFixedSizeVector<double,3>( 0.0, 0.0, 0.5 ) );
mtsOSGBody* hubble;
hubble = new mtsOSGBody( "hubble", path.Find("hst.3ds"), world, Rt, 0.8 );
taskManager->AddComponent( hubble );
osg::ref_ptr< osaOSGBody > background;
background = new osaOSGBody( path.Find("background.3ds"), world,
vctFrame4x4<double>() );
taskManager->Connect( camera->GetName(), "Input",
cmotion.GetName(), "Output" );
taskManager->Connect( hubble->GetName(), "Input",
hmotion.GetName(), "Output" );
taskManager->CreateAll();
taskManager->WaitForStateAll( mtsComponentState::READY );
taskManager->StartAll();
taskManager->WaitForStateAll( mtsComponentState::ACTIVE );
cmnGetChar();
std::cout << "ENTER to quit" << std::endl;
cmnGetChar();
taskManager->KillAll();
taskManager->Cleanup();
return 0;
}
int main(){
mtsTaskManager* taskManager = mtsTaskManager::GetInstance();
cmnLogger::SetMask( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskFunction( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskDefaultLog( CMN_LOG_ALLOW_ALL );
osg::ref_ptr< mtsODEWorld > world = NULL;
world = new mtsODEWorld( "world", 0.00001 );
taskManager->AddComponent( world.get() );
// Create a camera
int x = 0, y = 0;
int width = 640, height = 480;
double Znear = 0.1, Zfar = 10.0;
mtsOSGMono* camera;
camera = new mtsOSGMono( "camera",
world,
x, y, width, height,
55.0, ((double)width)/((double)height),
Znear, Zfar );
taskManager->AddComponent( camera );
cmnPath path;
path.AddRelativeToCisstShare("/models/WAM");
vctFrame4x4<double> Rtw0;
std::vector< std::string > models;
models.push_back( path.Find("l1.obj") );
models.push_back( path.Find("l2.obj") );
models.push_back( path.Find("l3.obj") );
models.push_back( path.Find("l4.obj") );
models.push_back( path.Find("l5.obj") );
models.push_back( path.Find("l6.obj") );
models.push_back( path.Find("l7.obj") );
mtsODEManipulator* WAM;
WAM = new mtsODEManipulator( "WAM",
0.001,
OSA_CPU1,
20,
models,
world,
Rtw0,
path.Find("wam7.rob"),
path.Find("l0.obj"),
vctDynamicVector<double>( 7, 0.0 ) );
taskManager->AddComponent( WAM );
WAMMotion motion( 0.001 );
taskManager->AddComponent( &motion );
taskManager->Connect( motion.GetName(), "Input", WAM->GetName(), "Output" );
taskManager->Connect( motion.GetName(), "Output", WAM->GetName(), "Input" );
taskManager->CreateAll();
taskManager->WaitForStateAll( mtsComponentState::READY );
taskManager->StartAll();
taskManager->WaitForStateAll( mtsComponentState::ACTIVE );
cmnGetChar();
std::cout << "ENTER to quit" << std::endl;
cmnGetChar();
taskManager->KillAll();
taskManager->Cleanup();
return 0;
}
int main(int argc, char * argv[])
{
// log configuration
cmnLogger::SetMask(CMN_LOG_ALLOW_ALL);
cmnLogger::SetMaskFunction(CMN_LOG_ALLOW_ALL);
cmnLogger::SetMaskDefaultLog(CMN_LOG_ALLOW_ALL);
cmnLogger::AddChannel(std::cout, CMN_LOG_ALLOW_ERRORS_AND_WARNINGS);
// set the log level of detail on select components
cmnLogger::SetMaskClassMatching("mts", CMN_LOG_ALLOW_ALL);
// enable system-wide thread-safe logging
#ifdef MTS_LOGGING
mtsManagerLocal::SetLogForwarding(true);
#endif
std::string globalComponentManagerIP;
int stateCollectionFlag = 0;
if (argc != 2) {
std::cerr << "Usage: " << argv[0] << " [GlobalManagerIP] [flagForDataCollection]" << std::endl;
std::cerr << " GlobalManagerIP is set as 127.0.0.1 by default" << std::endl;
}
// Set global component manager's ip and argument type
// If flag is not specified, or not 1, then use generic type (mtsDouble)
if (argc == 1) {
globalComponentManagerIP = "localhost";
} else if (argc == 2) {
globalComponentManagerIP = argv[1];
}else if (argc == 3) {
globalComponentManagerIP = argv[1];
stateCollectionFlag = atoi(argv[2]);
} else {
exit(-1);
}
std::cout << "Starting server, IP = " << globalComponentManagerIP << " 'q' to stop" << std::endl;
if(stateCollectionFlag){
std::cout << " with data collection. 's' to start/stop data collection" << std::endl;
}
// Get the TaskManager instance and set operation mode
mtsManagerLocal * componentManager;
try {
componentManager = mtsManagerLocal::GetInstance(globalComponentManagerIP, "ProcessClient");
} catch (...) {
CMN_LOG_INIT_ERROR << "Failed to initialize local component manager" << std::endl;
return 1;
}
// client
mtsMedtronicStealthlinkExampleComponent * componentExample;
if(stateCollectionFlag)
componentExample= new mtsMedtronicStealthlinkExampleComponent("Example", 50 * cmn_ms, true);
else
componentExample = new mtsMedtronicStealthlinkExampleComponent("Example", 50 * cmn_ms);
// add the components to the component manager
componentManager->AddComponent(componentExample);
// Connect the test component to the Stealthlink component
if (!componentManager->Connect("ProcessClient", componentExample->GetName(), "Stealthlink",
"ProcessServer", "Stealthlink", "Controller")) {
CMN_LOG_INIT_ERROR << "Could not connect test component to Stealthlink component." << std::endl;
return 0;
}
// Now, connect to the tools (we assume these are pre-defined in the XML file)
if (!componentManager->Connect("ProcessClient", componentExample->GetName(), "Pointer",
"ProcessServer", "Stealthlink", "Pointer")) {
CMN_LOG_INIT_WARNING << "Could not connect test component to Pointer tool." << std::endl;
}
if (!componentManager->Connect("ProcessClient", componentExample->GetName(), "Frame",
"ProcessServer", "Stealthlink", "Frame")) {
CMN_LOG_INIT_WARNING << "Could not connect test component to Frame tool." << std::endl;
}
// Connect the registration interface
if (!componentManager->Connect("ProcessClient", componentExample->GetName(), "Registration",
"ProcessServer", "Stealthlink", "Registration")) {
CMN_LOG_INIT_ERROR << "Could not connect test component to Registration interface." << std::endl;
return 0;
}
// Connect the exam information interface
if (!componentManager->Connect("ProcessClient", componentExample->GetName(), "ExamInformation",
"ProcessServer", "Stealthlink", "ExamInformation")) {
CMN_LOG_INIT_ERROR << "Could not connect test component to ExamInformation interface." << std::endl;
return 0;
}
if(stateCollectionFlag)
{
if (!componentManager->Connect("ProcessClient", componentExample->GetName(), "CollectorState",
"ProcessServer", "StealthlinkStateCollector", "Control")) {
CMN_LOG_INIT_ERROR << "Could not connect test component to Control interface." << std::endl;
return 0;
}
}
// create the tasks, i.e. find the commands
componentManager->CreateAll();
componentManager->WaitForStateAll(mtsComponentState::READY);
// start the periodic Run
componentManager->StartAll();
componentManager->WaitForStateAll(mtsComponentState::ACTIVE);
// wait for keyboard input in command window
int ch;
// execution result used by all functions
mtsExecutionResult executionResult;
bool GCMActive = true;
bool started = false;
while (GCMActive && ch != 'q') {
osaSleep(5.0 * cmn_ms);
GCMActive = componentManager->IsGCMActive();
ch = cmnGetChar();
switch (ch) {
case 's':
if(started)
{
if(componentExample->CollectorState.StopCollection.IsValid())
{
executionResult = componentExample->CollectorState.StopCollection();
osaSleep(0.1 * cmn_s);
std::cout << "Stop data collection" << std::endl;
started = false;
}
}
else
{
if(componentExample->CollectorState.StartCollection.IsValid())
{
executionResult = componentExample->CollectorState.StartCollection();
osaSleep(0.1 * cmn_s);
if(executionResult.IsOK())
{
std::cout << "Start data collection" << std::endl;
started = true;
}
else
std::cout << "StartCollection failed to execute." << std::endl;
}
}
break;
default:
break;
}
}
if (!GCMActive) {
CMN_LOG_RUN_ERROR << "Global Component Manager is disconnected" << std::endl;
}
// cleanup
componentManager->KillAll();
componentManager->WaitForStateAll(mtsComponentState::FINISHED, 20.0 * cmn_s);
// delete components
delete componentExample;
componentManager->Cleanup();
return 0;
}
int main(int argc, char *argv[])
{
srand(time(NULL));
cmnLogger::AddChannel(std::cout, CMN_LOG_ALLOW_ERRORS_AND_WARNINGS);
// Enable safety framework
mtsComponentManager::InstallSafetyCoordinator();
mtsManagerLocal * ComponentManager = 0;
try {
ComponentManager = mtsComponentManager::GetInstance();
} catch (...) {
std::cerr << "Failed to initialize local component manager" << std::endl;
return 1;
}
// Create and setup components
SensorWrapper sensorWrapper("Sensor", PERIOD);
Control control("Control", PERIOD);
UI ui("UI", PERIOD);
SCASSERT(ComponentManager->AddComponent(&sensorWrapper));
SCASSERT(ComponentManager->AddComponent(&control));
SCASSERT(ComponentManager->AddComponent(&ui));
// Read json file
std::string fileName(JSON_FOLDER"/Sensor.json");
if (!GetSafetyCoordinator->ReadConfigFile(fileName)) {
std::cerr << "Failed to read json file: " << fileName << std::endl;
return 1;
}
fileName = JSON_FOLDER"/Control.json";
if (!GetSafetyCoordinator->ReadConfigFile(fileName)) {
std::cerr << "Failed to read json file: " << fileName << std::endl;
return 1;
}
CONNECT_LOCAL(sensorWrapper.GetName(), "SensorValue",
control.GetName(), "ReadSensorValue");
CONNECT_LOCAL(control.GetName(), "ControlValue",
ui.GetName(), "ReadControlValue");
// Install data collector
mtsCollectorState collectorSensor(sensorWrapper.GetName(),
sensorWrapper.GetDefaultStateTableName(),
mtsCollectorBase::COLLECTOR_FILE_FORMAT_CSV);
collectorSensor.AddSignal("SensorValue");
collectorSensor.AddSignal("SensorValue2");
SCASSERT(ComponentManager->AddComponent(&collectorSensor));
collectorSensor.Connect();
ComponentManager->CreateAll();
ComponentManager->WaitForStateAll(mtsComponentState::READY);
ComponentManager->StartAll();
ComponentManager->WaitForStateAll(mtsComponentState::ACTIVE);
// start data collection
collectorSensor.StartCollection(0.0);
std::cout << "Press 'q' to quit." << std::endl;
// loop until 'q' is pressed
int key = ' ';
while (key != 'q') {
key = cmnGetChar();
osaSleep(100 * cmn_ms);
}
std::cout << std::endl;
// stop data collection
collectorSensor.StopCollection(0.0);
std::cout << "Cleaning up... " << std::flush;
ComponentManager->KillAll();
ComponentManager->WaitForStateAll(mtsComponentState::FINISHED, 2.0 * cmn_s);
ComponentManager->Cleanup();
std::cout << "Done\n";
return 0;
}
int main(){
mtsTaskManager* taskManager = mtsTaskManager::GetInstance();
cmnLogger::SetMask( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskFunction( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskDefaultLog( CMN_LOG_ALLOW_ALL );
osg::ref_ptr< mtsODEWorld > world = NULL;
world = new mtsODEWorld( "world", 0.0001, vctFixedSizeVector<double,3>(0.0) );
taskManager->AddComponent( world.get() );
// Create a camera
int x = 0, y = 0;
int width = 640, height = 480;
double Znear = 0.1, Zfar = 10.0;
mtsOSGMono* camera;
camera = new mtsOSGMono( "camera",
world,
x, y,
width, height,
55.0, ((double)width)/((double)height),
Znear, Zfar );
taskManager->AddComponent( camera );
cmnPath path;
path.AddRelativeToCisstShare("/models/BH");
std::string l0 = path.Find("l0.rob", cmnPath::READ);
std::string l1 = path.Find("l1.rob", cmnPath::READ);
std::string l2 = path.Find("l2.rob", cmnPath::READ);
std::string l3 = path.Find("l3.rob", cmnPath::READ);
std::string f1f2 = path.Find("f1f2.rob", cmnPath::READ);
std::string f3 = path.Find("f3.rob", cmnPath::READ);
vctFrame4x4<double> Rtw0;
Rtw0[2][3] = 0.1;
mtsODEBarrettHand* BH;
BH = new mtsODEBarrettHand( "BH",
0.001,
OSA_CPU1,
20,
l0,
l1,
l2,
l3,
world,
Rtw0,
f1f2,
f3 );
taskManager->AddComponent( BH );
BHMotion motion;
taskManager->AddComponent( &motion );
taskManager->Connect( motion.GetName(), "Input", BH->GetName(), "Output" );
taskManager->Connect( motion.GetName(), "Output", BH->GetName(), "Input" );
taskManager->CreateAll();
taskManager->WaitForStateAll( mtsComponentState::READY );
taskManager->StartAll();
taskManager->WaitForStateAll( mtsComponentState::ACTIVE );
cmnGetChar();
std::cout << "ESC to quit" << std::endl;
cmnGetChar();
taskManager->KillAll();
taskManager->Cleanup();
return 0;
}
int main( ){
mtsTaskManager* taskManager = mtsTaskManager::GetInstance();
cmnLogger::SetMask( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskFunction( CMN_LOG_ALLOW_ALL );
cmnLogger::SetMaskDefaultLog( CMN_LOG_ALLOW_ALL );
// Create the OSG world
osg::ref_ptr< osaOSGWorld > world = new osaOSGWorld;
// Create OSG camera
int x = 0, y = 0;
int width = 640, height = 480;
double Znear = 0.1, Zfar = 10.0;
osg::Node::NodeMask maskleft = 0x01;
osg::Node::NodeMask maskright = 0x02;
mtsOSGStereo* camera;
camera = new mtsOSGStereo( "camera",
world,
x, y,
width, height,
55.0, ((double)width)/((double)height),
Znear, Zfar,
0.1 );
camera->setCullMask( maskleft, osaOSGStereo::LEFT );
camera->setCullMask( maskright, osaOSGStereo::RIGHT );
taskManager->AddComponent( camera );
// create the hubble motion
HubbleMotion hmotion;
taskManager->AddComponent( &hmotion );
// create hubble
cmnPath path;
path.AddRelativeToCisstShare("/models/hubble");
path.AddRelativeToCisstShare("/movies");
vctFrame4x4<double> Rt( vctMatrixRotation3<double>(),
vctFixedSizeVector<double,3>( 0.0, 0.0, 0.5 ) );
mtsOSGBody* hubble;
hubble = new mtsOSGBody( "hubble", path.Find("hst.3ds"), world, Rt, 1.0, .5 );
taskManager->AddComponent( hubble );
// connect the motion to hubble
taskManager->Connect( hubble->GetName(), "Input",
hmotion.GetName(), "Output" );
// start the components
taskManager->CreateAll();
taskManager->WaitForStateAll( mtsComponentState::READY );
taskManager->StartAll();
taskManager->WaitForStateAll( mtsComponentState::ACTIVE );
// Start the svl stuff
svlInitialize();
// Creating SVL objects
svlStreamManager streamleft;
svlFilterSourceVideoFile sourceleft(1);
svlOSGImage imageleft( -0.5, -0.5, 1, 1, world );
// Configure the filters
sourceleft.SetFilePath( path.Find( "left.mpg" ) );
imageleft.setNodeMask( maskleft );
streamleft.SetSourceFilter( &sourceleft );
sourceleft.GetOutput()->Connect( imageleft.GetInput() );
svlStreamManager streamright;
svlFilterSourceVideoFile sourceright(1);
svlOSGImage imageright( -0.5, -0.5, 1, 1, world );
sourceright.SetFilePath( path.Find( "right.mpg" ) );
imageright.setNodeMask( maskright );
streamright.SetSourceFilter( &sourceright );
sourceright.GetOutput()->Connect( imageright.GetInput() );
// start the streams
if (streamleft.Play() != SVL_OK)
{ std::cerr << "Cannot start left stream." <<std::endl; }
if (streamright.Play() != SVL_OK)
{ std::cerr << "Cannot start right stream." <<std::endl; }
std::cout << "ENTER to exit." << std::endl;
cmnGetChar();
cmnGetChar();
streamleft.Release();
streamright.Release();
taskManager->KillAll();
taskManager->Cleanup();
return 0;
}
int main(int argc, char** argv)
{
cmnLogger::SetMask(CMN_LOG_ALLOW_ALL);
cmnLogger::SetMaskFunction(CMN_LOG_ALLOW_ALL);
cmnLogger::SetMaskDefaultLog(CMN_LOG_ALLOW_ALL);
cmnCommandLineOptions options;
const std::string configFilePrefix = "camera-viewer";
int portNumber = 0;
std::string codecName = ".njpg";
int numberOfChannels = 1;
int latencyInFrames = 0;
unsigned int width = 0;
unsigned int height = 0;
int numberOfThreads = 4;
options.AddOptionOneValue("t", "threads",
"Number of threads, default is 4",
cmnCommandLineOptions::OPTIONAL_OPTION, &numberOfThreads);
options.AddOptionOneValue("c", "channels",
"Number of channels, 1 for mono (default), 2 for stereo",
cmnCommandLineOptions::OPTIONAL_OPTION, &numberOfChannels);
options.AddOptionOneValue("p", "port",
"IP port for network based codec",
cmnCommandLineOptions::OPTIONAL_OPTION, &portNumber);
options.AddOptionNoValue("d", "dual-port",
"Create two ports to send left/right separately (default is single port)",
cmnCommandLineOptions::OPTIONAL_OPTION);
options.AddOptionOneValue("w", "width",
"Resize width (if specified, requires height)",
cmnCommandLineOptions::OPTIONAL_OPTION, &width);
options.AddOptionOneValue("h", "height",
"Resize height (if specified, requires width)",
cmnCommandLineOptions::OPTIONAL_OPTION, &height);
options.AddOptionNoValue("f", "flip-horizontal",
"Flip image left to right",
cmnCommandLineOptions::OPTIONAL_OPTION);
options.AddOptionOneValue("l", "latency",
"Add latency (in number of frames)",
cmnCommandLineOptions::OPTIONAL_OPTION, &latencyInFrames);
options.AddOptionNoValue("s", "save-configuration",
std::string("Save camera configuration in ") + configFilePrefix + std::string("-{mono,stereo}.dat"),
cmnCommandLineOptions::OPTIONAL_OPTION);
options.AddOptionNoValue("n", "no-window",
"don't display preview",
cmnCommandLineOptions::OPTIONAL_OPTION);
std::string errorMessage;
if (!options.Parse(argc, argv, errorMessage)) {
std::cerr << "Error: " << errorMessage << std::endl;
options.PrintUsage(std::cerr);
return -1;
}
if ((numberOfChannels != 1) && (numberOfChannels != 2)) {
std::cerr << "Error: number of channels can be either 1 or 2." << std::endl;
return -1;
}
std::string configFile = configFilePrefix;
if (numberOfChannels == 1) {
configFile.append("-mono.dat");
} else {
configFile.append("-stereo.dat");
}
if ((width != 0) || (height != 0)) {
if ((width == 0) || (height == 0)) {
std::cerr << "Error: you need to specify both width and height, both need to be greater than 0." << std::endl;
return -1;
}
}
svlInitialize();
// connect the source to the stream
svlFilterSourceVideoCapture source(numberOfChannels);
if (source.LoadSettings(configFile.c_str()) != SVL_OK) {
source.DialogSetup(SVL_LEFT);
source.DialogSetup(SVL_RIGHT);
}
if (options.IsSet("save-configuration")) {
source.SaveSettings(configFile.c_str());
}
svlFilterImageWindow previewWindow;
previewWindow.SetName("Video");
previewWindow.SetTitle("cisstCameraViewer");
svlStreamManager stream(numberOfThreads);
stream.SetSourceFilter(&source);
// connect the source to next filter
svlFilterOutput * output;
output = source.GetOutput();
// first resize if needed
svlFilterImageResizer resize;
if (width != 0) {
resize.SetName("Resize");
resize.SetInterpolation(true);
resize.SetOutputSize(width, height, SVL_LEFT);
resize.SetOutputSize(width, height, SVL_RIGHT);
output->Connect(resize.GetInput());
output = resize.GetOutput();
}
// flip if needed
svlFilterImageFlipRotate flip;
if (options.IsSet("flip-horizontal")) {
flip.SetHorizontalFlip(true);
output->Connect(flip.GetInput());
output = flip.GetOutput();
}
// latency if needed
svlFilterAddLatency latency;
if (latencyInFrames > 0) {
latency.SetFrameDelayed(latencyInFrames);
output->Connect(latency.GetInput());
output = latency.GetOutput();
}
// writer on network
svlFilterVideoFileWriter writer;
svlFilterStereoImageJoiner stereoJoiner;
if (options.IsSet("port")) {
// detect if codec is available
svlVideoCodecBase * codec = svlVideoIO::GetCodec(codecName);
if (codec == 0) {
std::string formatlist;
svlVideoIO::GetFormatList(formatlist);
std::cerr << "Error: can't find codec " << codecName << std::endl
<< "Supported formats:" << std::endl
<< formatlist << std::endl;
return -1;
}
svlVideoIO::Compression * compr = codec->GetCompression();
svlVideoIO::ReleaseCodec(codec);
compr->data[0] = 75;
writer.SetCodecParams(compr);
svlVideoIO::ReleaseCompression(compr);
std::stringstream filePath;
filePath << "@" << portNumber << codecName;
std::cout << "Opening network using " << filePath.str() << std::endl;
// stereo
if (numberOfChannels == 2) {
// two channels
if (options.IsSet("dual-port")) {
writer.SetFilePath(filePath.str(), SVL_LEFT);
filePath.str(std::string());
filePath << "@" << portNumber + 1 << codecName;
std::cout << "Opening network using " << filePath.str() << std::endl;
writer.SetFilePath(filePath.str(), SVL_RIGHT);
} else {
// join the two channels using the stereo image joiner
output->Connect(stereoJoiner.GetInput());
output = stereoJoiner.GetOutput();
writer.SetFilePath(filePath.str());
}
} else {
writer.SetFilePath(filePath.str());
}
writer.OpenFile();
output->Connect(writer.GetInput());
output = writer.GetOutput();
}
// connect the last filter to preview if desired
if (!options.IsSet("no-window")) {
output->Connect(previewWindow.GetInput());
}
if (stream.Play() != SVL_OK) {
std::cerr << "Failed to start the stream." << std::endl;
return 0;
}
std::cout << argv[0] << " started, press 'q' to stop." << std::endl;
char c;
do {
c = cmnGetChar();
switch (c) {
case '+':
latency.UpLatency();
break;
case '-':
latency.DownLatency();
break;
}
} while (c != 'q');
std::cout << "Stopping video stream." << std::endl;
stream.Release();
cmnLogger::Kill();
return 0;
}
