virtual void SetUp()
{
const size_t usableBlocksPerPage = (pageSize / blockSize) - 1;
const size_t availablePages = maxSize / pageSize;
allocations = availablePages * usableBlocksPerPage;
allocator.reset(new SmallObjectAllocator(PageManager::create(maxSize, pageSize), blockSize));
}
static
Recorder* GetInstance()
{
if (!instance)
{
instance.reset(new RASP24Recorder);
}
return instance.get();
}
void objectAdded(Object* object)
{
if (currentStepObject) {
return;
}
currentStepObject.reset(object->clone());
currentStepRecorded = false;
}
void load(
Archive & ar,
boost::scoped_ptr< T > & t,
const unsigned int /* version */
){
T* r;
ar >> boost::serialization::make_nvp("scoped_ptr", r);
t.reset(r);
}
bool set_disabled(SetDisabledRequest &request, SetDisabledResponse &response)
{
disabled = request.disabled;
if (disabled)
{
c3trajectory.reset();
}
return true;
}
/** component start method, starts thread */
virtual void start()
{
if ( !m_running )
{
m_bStop = false;
m_running = true;
m_pThread.reset( new boost::thread( boost::bind( &KeyboardEvent::mainLoop, this ) ) );
}
}
TranslatorRoster*
TranslatorRoster::default_roster()
{
static boost::scoped_ptr<TranslatorRoster> roster;
if(! roster)
roster.reset(new TranslatorRoster);
return roster.get();
}
static void cleanup(void)
{
mgr = NULL;
staticScene = NULL;
dynamicScene = NULL;
win = NULL;
dynamicVp = NULL;
spSimpleFBO.reset();
}
virtual void handle_stop()
{
if (acceptor_ && acceptor_->is_open())
{
acceptor_->close();
std::cout << "Server stopped" << std::endl;
}
acceptor_.reset();
}
static void cleanup(void)
{
mgr = nullptr;
staticScene = nullptr;
dynamicScene = nullptr;
win = nullptr;
dynamicVp = nullptr;
spSimpleFBO.reset();
}
CTextInputWindow()
: FK2DEngine::CFKWindow( 300, 200, false )
{
SetCaption( L"自由骑士笃志引擎：字符输入测试" );
SetBackgroudColor( FK2DEngine::CColor::YELLOW );
// 设置字体
m_pFont.reset( new FK2DEngine::CFont( Graphics(), L"Sans MT 936_S60", 20 ) );
for( unsigned int nIndex = 0; nIndex < LengthOf( m_pTextFields ); ++nIndex )
{
m_pTextFields[nIndex].reset( new CTextField( *this, *m_pFont, 50, 30 + nIndex * 50 ) );
}
// 开动计时器
m_Timer.Play();
// 隐藏真实鼠标，自定虚拟鼠标
::ShowCursor( FALSE );
// 设置自己鼠标图片
m_pCursor.reset( new FK2DEngine::CImage( Graphics(), FK2DEngine::ShareResourcePrefix() + L"rc/media/Cursor.png", false ) );
}
/*! @brief configure the detector state
*
* The configure method is called once when the ECTO cell is launched,
* and is designed to initialise the detector state and load models,
* parameters, etc.
*
* @param params the parameters made available through the config file and
* python bindings
* @param inputs for initializing inputs, if necessary
* @param outputs for initializing outputs, if necessary
*/
void configure(const tendrils& params, const tendrils& inputs,
const tendrils& outputs)
{
std::cout << "MODEL: " << *model_file_ << std::endl;
// create the model object and deserialize it
FileStorageModel model;
model.deserialize(*model_file_);
// create the visualizer
visualizer_.reset(new Visualize(model.name()));
// create the PartsBasedDetector and distribute the model parameters
detector_.reset(new PartsBasedDetector<double>);
detector_->distributeModel(model);
// set the model_name
model_name_ = model.name();
}
MainClass(int argc, const char *argv[])
:argv_(argv)
{
rg_.reset(new RegistryPO(argc,argv));
util::initLogger ( argc, argv );
FORCELINFO ( argv[0] << " starts!" );
FORCELINFO ( rg_->dump ( "CONFIG parameters:\n====================="
, "=====================" ) );
}
void InputEventsWestonTest::SetUp()
{
WestonTest::SetUp();
clientLibrary.Load();
eglLibrary.Load();
xkbCommonLibrary.Load();
xkbContext.reset(CXKBKeymap::CreateXKBContext(xkbCommonLibrary),
boost::bind(&IDllXKBCommon::xkb_context_unref,
&xkbCommonLibrary, _1));
keymap.reset(new CXKBKeymap(
xkbCommonLibrary,
CXKBKeymap::CreateXKBKeymapFromNames(xkbCommonLibrary,
xkbContext.get(),
"evdev",
"pc105",
"us",
"",
"")));
display.reset(new xw::Display(clientLibrary));
queue.reset(CreateEventQueue());
registry.reset(new xw::Registry(clientLibrary,
display->GetWlDisplay(),
*this));
loop.reset(new xwe::Loop(listener, *queue));
/* Wait for the seat, shell, compositor to appear */
WaitForSynchronize();
ASSERT_TRUE(input.get() != NULL);
ASSERT_TRUE(compositor.get() != NULL);
ASSERT_TRUE(shell.get() != NULL);
ASSERT_TRUE(xbmcWayland.get() != NULL);
/* Wait for input devices to appear etc */
WaitForSynchronize();
surface.reset(new xw::Surface(clientLibrary,
compositor->CreateSurface()));
shellSurface.reset(new xw::ShellSurface(clientLibrary,
shell->CreateShellSurface(
surface->GetWlSurface())));
openGLSurface.reset(new xw::OpenGLSurface(eglLibrary,
surface->GetWlSurface(),
SurfaceWidth,
SurfaceHeight));
wl_shell_surface_set_toplevel(shellSurface->GetWlShellSurface());
surface->Commit();
}
void InputEventsWestonTest::WaitForSynchronize()
{
synchronized = false;
syncCallback.reset(new xw::Callback(clientLibrary,
display->Sync(),
boost::bind(&InputEventsWestonTest::Synchronize,
this)));
while (!synchronized)
loop->Dispatch();
}
void CameraV4LPublisher::open()
{
locateCameraNode();
if ( _node == -1 )
throw std::runtime_error("Error in CameraV4LPublisher::open(): device not found");
ROS_INFO_STREAM("Creating cv::VideoCapture in node " << _node);
_capture.reset( new cv::VideoCapture(_node) );
ROS_INFO_STREAM("Setting image width to " << _imageSize.width << " pixels");
_capture->set(CV_CAP_PROP_FRAME_WIDTH, _imageSize.width);
ROS_INFO_STREAM("Setting image height to " << _imageSize.height << " pixels");
_capture->set(CV_CAP_PROP_FRAME_HEIGHT, _imageSize.height);
//set up ROS publisher
_imageTransport.reset( new image_transport::ImageTransport(_nh) );
_cameraPublisher.reset( new image_transport::CameraPublisher(
_imageTransport->advertiseCamera(_nh.getNamespace()+"/image", 1)) );
}
Connection(const std::string &connection_str, const std::string ns)
: ns_(ns), closed_(false) {
try {
conn_.reset(mongo::ScopedDbConnection::getScopedDbConnection(connection_str));
} catch (mongo::DBException &de) {
std::string err_msg = "Mongodb Plugin: ";
err_msg += de.toString();
err_msg += "\n";
throw mapnik::datasource_exception(err_msg);
}
}
/** gets a scoped_block given a key, or leaves empty
** if the key is not found */
void get(boost::scoped_ptr< variable_store::scoped_block > & p,
const Key & key)
{
boost::mutex::scoped_lock lock(m_mutex);
// if key is found, loads index into the scoped block
typename hm_key_location::const_iterator it = m_key_location.find(key);
if (it == m_key_location.end())
return;
p.reset( new variable_store::scoped_block(m_variable_store, it->second.block_size, it->second.index) );
}
void timer_callback(const ros::TimerEvent &) {
if (!c3trajectory) return;
ros::Time now = ros::Time::now();
if (actionserver.isPreemptRequested()) {
current_waypoint = c3trajectory->getCurrentPoint();
current_waypoint.r.qdot = subjugator::Vector6d::Zero(); // zero velocities
current_waypoint_t = now;
// don't try to make output c3 continuous when cancelled - instead stop as quickly as possible
c3trajectory.reset(new subjugator::C3Trajectory(current_waypoint.r, limits));
c3trajectory_t = now;
}
if (actionserver.isNewGoalAvailable()) {
boost::shared_ptr<const uf_common::MoveToGoal> goal = actionserver.acceptNewGoal();
current_waypoint = subjugator::C3Trajectory::Waypoint(
Point_from_PoseTwist(goal->posetwist.pose, goal->posetwist.twist), goal->speed,
!goal->uncoordinated);
current_waypoint_t = now; // goal->header.stamp;
this->linear_tolerance = goal->linear_tolerance;
this->angular_tolerance = goal->angular_tolerance;
c3trajectory_t = now;
}
while ((c3trajectory_t + traj_dt < now) and ros::ok()) {
// ROS_INFO("Acting");
c3trajectory->update(traj_dt.toSec(), current_waypoint,
(c3trajectory_t - current_waypoint_t).toSec());
c3trajectory_t += traj_dt;
}
PoseTwistStamped msg;
msg.header.stamp = c3trajectory_t;
msg.header.frame_id = fixed_frame;
msg.posetwist = PoseTwist_from_PointWithAcceleration(c3trajectory->getCurrentPoint());
trajectory_pub.publish(msg);
PoseStamped posemsg;
posemsg.header.stamp = c3trajectory_t;
posemsg.header.frame_id = fixed_frame;
posemsg.pose = Pose_from_Waypoint(current_waypoint);
waypoint_pose_pub.publish(posemsg);
if (actionserver.isActive() &&
c3trajectory->getCurrentPoint().is_approximately(
current_waypoint.r, max(1e-3, linear_tolerance), max(1e-3, angular_tolerance)) &&
current_waypoint.r.qdot == subjugator::Vector6d::Zero()) {
actionserver.setSucceeded();
}
}
virtual bool next() {
if (!nested_current)
return false;
while (!nested_current->next()) {
nested_current.reset();
++current;
if (current == end) {
// no more items
nested_current.reset();
valid = false;
return false;
}
nested_current.reset((*current)->lines());
}
valid = true;
return true;
}
void complete (const value_type& value)
{
boost::lock_guard<boost::mutex> lock(mutex);
if (finished)
return;
finished = true;
if (!started) {
value_ptr.reset(new value_type(value));
} else if (completed_handler) {
completed_handler(value);
}
}
bool Model::initString(const std::string& xml_string)
{
boost::shared_ptr<ModelInterface> model;
// necessary for COLLADA compatibility
if( IsColladaData(xml_string) ) {
ROS_DEBUG("Parsing robot collada xml string");
static boost::mutex PARSER_PLUGIN_LOCK;
static boost::scoped_ptr<pluginlib::ClassLoader<urdf::URDFParser> > PARSER_PLUGIN_LOADER;
boost::mutex::scoped_lock _(PARSER_PLUGIN_LOCK);
try
{
if (!PARSER_PLUGIN_LOADER)
PARSER_PLUGIN_LOADER.reset(new pluginlib::ClassLoader<urdf::URDFParser>("urdf_parser_plugin", "urdf::URDFParser"));
const std::vector<std::string> &classes = PARSER_PLUGIN_LOADER->getDeclaredClasses();
bool found = false;
for (std::size_t i = 0 ; i < classes.size() ; ++i)
if (classes[i].find("urdf/ColladaURDFParser") != std::string::npos)
{
boost::shared_ptr<urdf::URDFParser> instance = PARSER_PLUGIN_LOADER->createInstance(classes[i]);
if (instance)
model = instance->parse(xml_string);
found = true;
break;
}
if (!found)
ROS_ERROR_STREAM("No URDF parser plugin found for Collada files. Did you install the corresponding package?");
}
catch(pluginlib::PluginlibException& ex)
{
ROS_ERROR_STREAM("Exception while creating planning plugin loader " << ex.what() << ". Will not parse Collada file.");
}
}
else {
ROS_DEBUG("Parsing robot urdf xml string");
model = parseURDF(xml_string);
}
// copy data from model into this object
if (model){
this->links_ = model->links_;
this->joints_ = model->joints_;
this->materials_ = model->materials_;
this->name_ = model->name_;
this->root_link_ = model->root_link_;
return true;
}
else
return false;
}
void testCaseSetup_1() {
ooe.reset(new OneOfEach);
ooe->im_true = true;
ooe->im_false = false;
ooe->a_bite = 0x7f;
ooe->integer16 = 27000;
ooe->integer32 = 1 << 24;
ooe->integer64 = (uint64_t)6000 * 1000 * 1000;
ooe->double_precision = M_PI;
ooe->some_characters = "JSON THIS! \"\1";
ooe->zomg_unicode = "\xd7\n\a\t";
ooe->base64 = "\1\2\3\255";
}
/** allocs a scoped_block for a new key
** doesn't support reallocing on an existing key, maybe in the future */
void alloc(boost::scoped_ptr< variable_store::scoped_block > & p,
const Key & key,
size_t block_size)
{
boost::mutex::scoped_lock lock(m_mutex);
// don't support reallocing for now
typename hm_key_location::const_iterator it = m_key_location.find(key);
if (it != m_key_location.end())
throw std::invalid_argument("realloc not supported");
p.reset( new variable_store::scoped_block(m_variable_store, block_size) );
m_key_location[key] = location(p->block_size(), p->index());
}
virtual void handle_start()
{
tcp::resolver resolver(main_pool().io_service());
tcp::endpoint endpoint = *resolver.resolve(addr_query_);
acceptor_.reset(new tcp::acceptor(main_pool().io_service()));
acceptor_->open(endpoint.protocol());
acceptor_->set_option(tcp::acceptor::reuse_address(true));
acceptor_->bind(endpoint);
acceptor_->listen();
start_accept();
std::cout << "Server started" << std::endl;
}
~FiberControl(){
AUTO(it, g_stack_pool.begin());
for(;;){
if(it == g_stack_pool.end()){
stack.reset();
break;
}
if(!*it){
stack.swap(*it);
break;
}
++it;
}
}
VisualServo() : arm_("left"),
planning_group_name_(arm_+"_arm"),
camera_frame_(arm_+"_hand_camera")
{
move_group_.reset(new move_group_interface::MoveGroup(planning_group_name_));
move_group_->setPlanningTime(30.0);
move_group_->setPlannerId("RRTstark");
while(ros::ok())
{
// marker_pose_subscriber_ = node_.subscribe("ar_pose_marker",50, &VisualServo::marker_pose_callback, this);
// target_publisher_ = node_.advertise<geometry_msgs::Pose>("/visual_servo_target", 10);
servo_to_tag();
}
}
void odom_callback(const OdometryConstPtr &odom) {
if (c3trajectory) return; // already initialized
if (kill_listener.get_killed() || disabled) return; // only initialize when unkilled
subjugator::C3Trajectory::Point current =
Point_from_PoseTwist(odom->pose.pose, odom->twist.twist);
current.q[3] = current.q[4] = 0; // zero roll and pitch
current.qdot = subjugator::Vector6d::Zero(); // zero velocities
c3trajectory.reset(new subjugator::C3Trajectory(current, limits));
c3trajectory_t = odom->header.stamp;
current_waypoint = current;
current_waypoint_t = odom->header.stamp;
}
sub_match(const sub_match& that, bool
#ifdef BOOST_REGEX_MATCH_EXTRA
deep_copy
#endif
= true
)
: std::pair<BidiIterator, BidiIterator>(that),
matched(that.matched)
{
#ifdef BOOST_REGEX_MATCH_EXTRA
if(that.m_captures)
if(deep_copy)
m_captures.reset(new capture_sequence_type(*(that.m_captures)));
#endif
}
void train(DataView2D<FeatureType> samples,
DataView2D<int> labels,
int* sample_idxes,
size_t n_samples,
SplitGenerator split_generator,
RandomGen const& gen
)
{
// copy generator
RandomGen my_gen = gen;
// initialize root node
root_node.reset(new NodeT(0, params));
// train root node (other notes get trained recursively)
root_node->train(samples, labels, sample_idxes, n_samples, split_generator, my_gen);
}