C++ ModelManager::addSubComponent方法代码示例

bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;

  while(!connected)
    {
      try
        {
          LINFO("Trying Port:%d", port);
          sprintf(adapterStr, "default -p %i", port);
          itsAdapter = communicator()->createObjectAdapterWithEndpoints("SeaBee3SimulatorAdapter",
                                                                        adapterStr);
          connected = true;
        }
      catch(Ice::SocketException)
        {
          port++;
        }
    }

  //Create the manager and its objects
  itsMgr = new ModelManager("SeaBee3SimulatorServiceManager");

  nub::ref<OutputFrameSeries> ofs(new OutputFrameSeries(*itsMgr));
  itsMgr->addSubComponent(ofs);


  LINFO("Starting SeaBee3 Simulator");
  nub::ref<SeaBee3Simulator> subSim(new SeaBee3Simulator(*itsMgr, "SeaBee3Simulator", "SeaBee3Simulator"));
  itsMgr->addSubComponent(subSim);
  subSim->init(communicator(), itsAdapter);

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  while(1){
    Layout<PixRGB<byte> > outDisp;

    subSim->simLoop();
    Image<PixRGB<byte> > forwardCam = flipVertic(subSim->getFrame(1));
    Image<PixRGB<byte> > downwardCam = flipVertic(subSim->getFrame(2));

    outDisp = vcat(outDisp, hcat(forwardCam, downwardCam));

    ofs->writeRgbLayout(outDisp, "subSim", FrameInfo("subSim", SRC_POS));

    handle_keys(ofs, subSim);
  }


  return true;
}

bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

  //Create the topics
  SimEventsUtils::createTopic(communicator(), "SalientPointMessageTopic");

  //Create the adapter
  sprintf(adapterStr, "default -p %i", RobotBrainObjects::RobotBrainPort);
  itsAdapter = communicator()->createObjectAdapterWithEndpoints("SaliencyModule",
                                                                adapterStr);

  //Create the manager and its objects
  itsMgr = new ModelManager("SaliencyModuleService");

  LINFO("Starting SaliencyModule");
  nub::ref<SaliencyModuleI> ret(new SaliencyModuleI(*itsMgr));
  itsMgr->addSubComponent(ret);

  ret->init(communicator(), itsAdapter);

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  return true;
}

bool SeaBee3GUIService::start(int argc, char* argv[])
{
  QApplication app(argc, argv);

  itsMgr = new ModelManager("SeaBeeIIIGUIManager");

  char adapterStr[255];
  LINFO("Creating Adapter");
  sprintf(adapterStr, "default -p %i", 12345);
  itsAdapter = communicator()->createObjectAdapterWithEndpoints("RobotBrainPort",
      adapterStr);

  nub::ref<MainWindow> mainWindow(new MainWindow(*itsMgr));
  itsMgr->addSubComponent(mainWindow);

  LINFO("Starting Up GUI Comm");
  mainWindow->initIce(communicator(), itsAdapter);

  itsMgr->parseCommandLine(argc, argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  mainWindow->setGeometry(100,100,900,800);
  mainWindow->show();

  return app.exec();
}

bool RobotBrainServiceService::start(int argc, char* argv[])
#endif	
{
  MYLOGVERB = LOG_INFO;

  char adapterStr[255];

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;

  // try to connect to ports until successful
  LDEBUG("Opening Connection");
  while(!connected)
  {
    try
    {
      LINFO("Trying Port:%d", port);
      sprintf(adapterStr, "default -p %i", port);
      itsAdapter = communicator()->createObjectAdapterWithEndpoints
        ("GistSal_Navigation", adapterStr);
      connected = true;
    }
    catch(Ice::SocketException)
    {
      port++;
    }
  }

  //Create the manager and its objects
  itsMgr = new ModelManager("BeoLocalizationService");

  LINFO("Starting BeoLocalization System");
  nub::ref<BeoLocalizer>
    bl(new BeoLocalizer
        (*itsMgr, "BeoLocalizer", "BeoLocalizer"));
  LINFO("BeoLocalizer created");
  itsMgr->addSubComponent(bl);
  LINFO("BeoLocalizer Added As a subcomponent");
  bl->init(communicator(), itsAdapter);
  LINFO("BeoLocalizer initiated");

  // check command line inputs/options
  if (itsMgr->parseCommandLine((const int)argc, (const char**)argv,
                               "", 0, 0)
      == false) return(1);

  // FIXXX: in the future the map should be specificable 
  //        from the command line to allow for stand alone application

  // check app-Beobot2_GistSalLocalizer.C


  // activate manager and adapter
  itsAdapter->activate();
  itsMgr->start();

  return true;
}

bool RobotBrainServiceService::start(int argc, char* argv[])
#endif	
{
  MYLOGVERB = LOG_INFO;

  char adapterStr[255];

  //Create the topics
//  SimEventsUtils::createTopic(communicator(), "BeoGPSMessageTopic");

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;

  // try to connect to ports until successful
  LDEBUG("Opening Connection");
  while(!connected)
  {
    try
    {
      LINFO("Trying Port:%d", port);
      sprintf(adapterStr, "default -p %i", port);
      itsAdapter = communicator()->createObjectAdapterWithEndpoints
        ("BeoGPS", adapterStr);
      connected = true;
    }
    catch(Ice::SocketException)
    {
      port++;
    }
  }

  //Create the manager and its objects
  itsMgr = new ModelManager("BeoGPSService");

  LINFO("Starting BeoGPS System");
  nub::ref<BeoGPS> gps(new BeoGPS(*itsMgr, "BeoGPS", "BeoGPS"));
  LINFO("BeoGPS created");
  itsMgr->addSubComponent(gps);
  LINFO("BeoGPS Added As a subcomponent");
  gps->init(communicator(), itsAdapter);
  LINFO("BeoGPS initiated");

  // check command line inputs/options
  if (itsMgr->parseCommandLine
      (argc, argv, "<serdev>", 0, 0) == false)
    return(1);

  // let's configure our serial device:
//   gps->configureSerial(itsMgr->getExtraArg(0));
//   LINFO("Using: %s", itsMgr->getExtraArg(0).c_str());

  // activate manager and adapter
  itsAdapter->activate();
  itsMgr->start();

  return true;
}

bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

  LINFO("Creating Topic!");
  //Create the topics
//  SimEventsUtils::createTopic(communicator(), "BinFinderMessageTopic");

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;
  LDEBUG("Opening Connection");

  while(!connected)
  {
    try
    {
      LINFO("Trying Port:%d", port);
      sprintf(adapterStr, "default -p %i", port);
      itsAdapter = communicator()->createObjectAdapterWithEndpoints
        ("BinFinder",
          adapterStr);
      connected = true;
    }
    catch(Ice::SocketException)
    {
      port++;
    }
  }

  //Create the manager and its objects
        itsMgr = new ModelManager("BinFinderService");

  LINFO("Starting BinFinder");
  nub::ref<BinFinder> ret
    (new BinFinder(*itsMgr, "BinFinder1", "BinFinder2"));
  LINFO("BinFinder Created");
  itsMgr->addSubComponent(ret);
  LINFO("BinFinder Added As Sub Component");
  ret->init(communicator(), itsAdapter);
  LINFO("BinFinder Inited");

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  return true;
}

// ######################################################################
bool RobotBrainServiceService::start(int argc, char* argv[])
{
    MYLOGVERB = LOG_INFO;

    char adapterStr[255];

    //Create the adapter
    int port = RobotBrainObjects::RobotBrainPort;
    bool connected = false;

    // try to connect to ports until successful
    LDEBUG("Opening Connection");
    while(!connected)
    {
        try
        {
            LINFO("Trying Port:%d", port);
            sprintf(adapterStr, "default -p %i", port);
            itsAdapter = communicator()->createObjectAdapterWithEndpoints
                         ("RG_Lane", adapterStr);
            connected = true;
        }
        catch(Ice::SocketException)
        {
            port++;
        }
    }

    //Create the manager and its objects
    itsMgr = new ModelManager("RG_LaneService");

    LINFO("Starting RG_Lane System");
    nub::ref<RG_Lane>
    nav(new RG_Lane(*itsMgr, "RG_Lane", "RG_Lane"));
    LINFO("RG_Lane created");
    itsMgr->addSubComponent(nav);
    LINFO("RG_Lane Added As a subcomponent");
    nav->init(communicator(), itsAdapter);
    LINFO("RG_Lane initiated");

    // check command line inputs/options
    itsMgr->parseCommandLine(argc, argv, "", 0, 0);

    // activate manager and adapter
    itsAdapter->activate();
    itsMgr->start();

    return true;
}

bool RobotBrainServiceService::start(int argc, char* argv[])
{
  char adapterStr[255];

LINFO("Starting XBox Controller...");
  //Create the topics
 // SimEventsUtils::createTopic(communicator(), "XBox360RemoteControlMessageTopic");

  //Create the adapter
  int port = RobotBrainObjects::RobotBrainPort;
  bool connected = false;

  while(!connected)
    {
      try
        {
          LINFO("Trying Port:%d", port);
          sprintf(adapterStr, "default -p %i", port);
          itsAdapter = communicator()->createObjectAdapterWithEndpoints("XBox360RemoteControl",
                                                                        adapterStr);
          connected = true;
        }
      catch(Ice::SocketException)
        {
          port++;
        }
    }

  //Create the manager and its objects
  itsMgr = new ModelManager("XBox360RemoteControlService");

  LINFO("Starting XBox360RemoteControl");
  nub::ref<XBox360RemoteControlI> ret(new XBox360RemoteControlI(0, *itsMgr, "XBox360RemoteControl1", "XBox360RemoteControl2"));
  LINFO("XBox360RemoteControl Created");
  itsMgr->addSubComponent(ret);
  LINFO("XBox360RemoteControl Added As Sub Component");
  ret->init(communicator(), itsAdapter);
  LINFO("XBox360RemoteControl Inited");

  itsMgr->parseCommandLine((const int)argc, (const char**)argv, "", 0, 0);

  itsAdapter->activate();

  itsMgr->start();

  return true;
}

int main(int argc, const char **argv)
{
  // Instantiate a ModelManager:
  ModelManager *manager = new ModelManager("Test wiimote");

  nub::soft_ref<OutputFrameSeries> ofs(new OutputFrameSeries(*manager));
  manager->addSubComponent(ofs);

  //Create the GUI
  nub::soft_ref<GeneralGUI> pwiiGUI(new GeneralGUI(*manager, "PWiiGUI", "PWiiGUI", Dims(700,512)));
  manager->addSubComponent(pwiiGUI);

  //Create the PWiiBot Controller
  nub::soft_ref<PWiiController> controller(new PWiiController(*manager));
  manager->addSubComponent(controller);

  // Parse command-line:
  if (manager->parseCommandLine(argc, argv, "", 0, 0) == false) return(1);



  manager->exportOptions(MC_RECURSE);
  manager->start();
  sleep(1);
  setupGUI(pwiiGUI, ofs, controller);



  while(1) {

  }

//  sleep(1);


#ifdef HAVE_LIBWIIMOTE
/*        wiimote_t wiimote = WIIMOTE_INIT;
        //wiimote_report_t report = WIIMOTE_REPORT_INIT;

  LINFO("Press buttons 1 and 2 on the wiimote now to connect.");
  int nmotes = wiimote_discover(&wiimote, 1);
  if (nmotes == 0)
    LFATAL("no wiimotes were found");

  LINFO("found: %s\n", wiimote.link.r_addr);

  if (wiimote_connect(&wiimote, wiimote.link.r_addr) < 0) {
    LFATAL("Unable to connect to wiimote");
    Raster::waitForKey();
    }
    */

  /* Activate the first led on the wiimote. It will take effect on the
     next call to wiimote_update. */
/*
  wiimote.led.one  = 1;

  // let's get all our ModelComponent instances started:
  LINFO("Open ");

  LINFO("Status %i", wiimote_is_open(&wiimote));

  int speed = 100;
  int motor1_dir = 0;
  int motor1_vel = 0;

  int motor2_dir = 0;
  int motor2_vel = 0;

  Point2D<int> loc(128,128);

*/

//  while(wiimote_is_open(&wiimote))
//  {
    /* The wiimote_update function is used to synchronize the wiimote
       object with the real wiimote. It should be called as often as
       possible in order to minimize latency. */

  /*  if (wiimote_update(&wiimote) < 0) {
      wiimote_disconnect(&wiimote);
      break;
    }*/

                /* The wiimote object has member 'keys' which keep track of the
                   current key state. */
        /*
                if (wiimote.keys.home) { //press home to exit
                            wiimote_write_byte(&wiimote, 0x04a40001, motor1_dir);
                            wiimote_write_byte(&wiimote, 0x04a40002, 0);
                           wiimote_write_byte(&wiimote, 0x04a40003, motor2_dir);
                            wiimote_write_byte(&wiimote, 0x04a40004, 0);

                        LINFO("Shutting Down Motors and Gracefully Disconnecting...");

                        wiimote_disconnect(&wiimote);

                        LINFO("Disconnected, Goodbye!");
                }
                */
//.........这里部分代码省略.........

int main(const int argc, const char **argv)
{
  MYLOGVERB = LOG_INFO;
  ModelManager *mgr = new ModelManager("Test ObjRec");

  nub::ref<OutputFrameSeries> ofs(new OutputFrameSeries(*mgr));
  mgr->addSubComponent(ofs);

  nub::ref<InputFrameSeries> ifs(new InputFrameSeries(*mgr));
  mgr->addSubComponent(ifs);

  nub::ref<EnvSegmenterCannyContour> seg(new EnvSegmenterCannyContour(*mgr));
  mgr->addSubComponent(seg);

  mgr->exportOptions(MC_RECURSE);

  if (mgr->parseCommandLine(
        (const int)argc, (const char**)argv, "", 0, 0) == false)
    return 1;

  mgr->start();

  seg->setModelParamVal("CannyMinCos", 1.0);
  seg->setModelParamVal("CannyMaxArea", 6000);
  seg->setModelParamVal("CannyMaxArea", 12000);

  itsObjectDB.loadFrom("cards.vdb");
  while(1)
  {
    Image< PixRGB<byte> > inputImg;
    const FrameState is = ifs->updateNext();
    if (is == FRAME_COMPLETE)
      break;

    //grab the images
    GenericFrame input = ifs->readFrame();
    if (!input.initialized())
      break;
    inputImg = input.asRgb();

    Image<PixRGB<byte> > out;

    const Rectangle cardbox = seg->getFoa(inputImg, Point2D<int>(), NULL, &out);

    ofs->writeRGB(out, "input", FrameInfo("input", SRC_POS));

    if (cardbox.isValid())
    {
      Image<PixRGB<byte> > card =
        crop(inputImg, cardbox.getOverlap(inputImg.getBounds()));

      std::string cardName = recCard(card);

      if (cardName.length() == 0)
      {
        LINFO("Enter name for card:");
        std::getline(std::cin, cardName, '\n');

        if (cardName.length() > 0)
          trainCard(card, cardName);
      }

      writeText(card, Point2D<int>(0,0), cardName.c_str(),
          PixRGB<byte>(255), PixRGB<byte>(127));

      ofs->writeRGB(card, "card", FrameInfo("card", SRC_POS));
    }

    ofs->updateNext();
  }
  mgr->stop();

  return 0;

}

void setupGrabbers(ModelManager& manager)
{
  size_t cameraID = 0;
  while(true)
  {
    std::string dev = sformat("/dev/video%" ZU , grabbers.size());
    LINFO("Trying to open %s", dev.c_str());
    int fd = open(dev.c_str(), O_RDONLY);
    if (fd == -1) { LINFO("%s not found -- Skipping.", dev.c_str()); break; } else close(fd);

    // instantiate and configure a grabber:
    nub::ref<V4L2grabber> grabber(new V4L2grabber(manager, dev, dev));
    
    // do not export any command-line option to avoid clashes among grabber instances:
    grabber->forgetExports();

    // let's set everything by hand here to ensure consistency:
    grabber->setModelParamVal("FrameGrabberDevice", dev);

    grabber->setModelParamVal("FrameGrabberNbuf", 2);
    grabber->setModelParamVal("FrameGrabberStreaming", true); 
    grabber->setModelParamVal("FrameGrabberByteSwap", false);
    grabber->setModelParamVal("FrameGrabberDims", Dims(1280,720));
    grabber->setModelParamVal("FrameGrabberMode", VIDFMT_YUYV);
    grabber->setModelParamVal("FrameGrabberChannel", 0);

    // to make sure we will force the hardware to set its values, first set some trash values, then set the real values:
    // turn all auto controls to on:
    grabber->setModelParamVal("FrameGrabberWhiteBalTempAuto", true);
    grabber->setModelParamVal("FrameGrabberPowerLineFreq", 2);
    grabber->setModelParamVal("FrameGrabberBacklightComp", 1);
    grabber->setModelParamVal("FrameGrabberFocusAuto", true);
 
    // now turn all auto controls to off:
    grabber->setModelParamVal("FrameGrabberWhiteBalTempAuto", false);
    grabber->setModelParamVal("FrameGrabberPowerLineFreq", 0);
    grabber->setModelParamVal("FrameGrabberBacklightComp", 0);
    grabber->setModelParamVal("FrameGrabberExposureAuto", 3); // that's still auto
    grabber->setModelParamVal("FrameGrabberFocusAuto", false);
    grabber->setModelParamVal("FrameGrabberExposureAuto", 1); // now we are full manual for exposure
 
    // set all manual settings 1-off from what we want:
    grabber->setModelParamVal("FrameGrabberBrightness", 134);
    grabber->setModelParamVal("FrameGrabberContrast", 6);
    grabber->setModelParamVal("FrameGrabberSaturation", 84);
    grabber->setModelParamVal("FrameGrabberWhiteBalTemp", 3101);
    grabber->setModelParamVal("FrameGrabberExposureAbs", 39);
    grabber->setModelParamVal("FrameGrabberSharpness", 26);
    grabber->setModelParamVal("FrameGrabberFocus", focusval[cameraID] + 1);
    grabber->setModelParamVal("FrameGrabberZoom", 1);
 
    // and now the real values:
    grabber->setModelParamVal("FrameGrabberPowerLineFreq", 0); // should be set already but just in case...
    grabber->setModelParamVal("FrameGrabberBacklightComp", 0);
    grabber->setModelParamVal("FrameGrabberExposureAuto", 1);
    grabber->setModelParamVal("FrameGrabberWhiteBalTempAuto", false);
 
    grabber->setModelParamVal("FrameGrabberBrightness", 133);
    grabber->setModelParamVal("FrameGrabberContrast", 5);
    grabber->setModelParamVal("FrameGrabberSaturation", 83);
    grabber->setModelParamVal("FrameGrabberWhiteBalTemp", 3100);
    grabber->setModelParamVal("FrameGrabberSharpness", 25);
    grabber->setModelParamVal("FrameGrabberExposureAbs", 156);
    grabber->setModelParamVal("FrameGrabberFocusAuto", false);
    grabber->setModelParamVal("FrameGrabberFocus", focusval[cameraID]);
    grabber->setModelParamVal("FrameGrabberZoom", 0);
    
    // keep track of it:
    manager.addSubComponent(grabber);
    grabbers.push_back(grabber);
    LINFO("Added V4L2grabber for %s", dev.c_str());

    ++cameraID;
  }

  // Now look for the Imagize cam:

  // instantiate and configure a grabber:
  nub::ref<XCgrabber> grabber(new XCgrabber(manager, "Imagize", "Imagize"));
    
  // do not export any command-line option to avoid clashes among grabber instances:
  grabber->forgetExports();

  // let's set everything by hand here to ensure consistency:
  grabber->setModelParamString("XCGrabberFormatFile", "/home/ilab24/xcap/data/imagize-works.xsetup");
    grabber->setModelParamVal("FrameGrabberMode", VIDFMT_RGB24);
  grabber->setModelParamVal("FrameGrabberNbuf", 2);
  grabber->setModelParamVal("FrameGrabberDims", Dims(1280,1024));

  // keep track of it:
  manager.addSubComponent(grabber);
  grabbers.push_back(grabber);
  LINFO("Added XCgrabber for Imagize camera");
}