示例#1
0
文件: glview.cpp 项目: MzHub/flowabs
texture_2d tangent_flow_map(const texture_2d& src, float sigma) {
    texture_2d tmp0(src.clone_format());
    texture_2d tmp1(src.clone_format());
    texture_2d dst(src.clone_format());
    
    glsl_program sst("sst_fs.glsl");
    sst.use();
    sst.bind_sampler("img", src);
    sst.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
    sst.draw(&tmp0);

    glsl_program gauss("gauss_fs.glsl");
    gauss.use();
    gauss.bind_sampler("img", tmp0);
    gauss.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
    gauss.set_uniform_1f("sigma", sigma);
    gauss.draw(&tmp1);                  

    glsl_program tfm("tfm_fs.glsl");
    tfm.use();
    tfm.bind_sampler("img", tmp1);
    tfm.set_uniform_2f("img_size", (float)src.get_width(), (float)src.get_height());
    tfm.draw(&dst);

    return dst;
}
示例#2
0
 static bool Process(ParseParam<Iter>& param) {
   Group::ptr group = GetGroup(param);
   Shape::ptr tfm(new Shape(param.currentNode));
   group->children.add(tfm);
   param.currentNode = tfm;
   return true;
 }
示例#3
0
void GoalCallback(const geometry_msgs::PoseStampedConstPtr &msg)
{
  int i, j, k;
  double roll, pitch, yaw, tfyaw;

  tf::Vector3 tfpoint = TransformPoint(msg->pose);

  gx = (int)(tfpoint.getX()*10);
  gy = (int)(tfpoint.getY()*10);
  dgx = msg->pose.position.x;
  dgy = msg->pose.position.y;

  tf::Quaternion quat(msg->pose.orientation.x, msg->pose.orientation.y,
		      msg->pose.orientation.z, msg->pose.orientation.w);
  tf::Matrix3x3 m(quat);
  m.getRPY(roll, pitch, yaw);
  dgtheta = yaw; // in real world

  tf::Quaternion tfquat = _transform * quat;
  tf::Matrix3x3 tfm(tfquat);
  tfm.getRPY(roll, pitch, tfyaw);
  if (tfyaw < 0) {tfyaw+=2*M_PI;}
  gtheta = (int)(tfyaw/THETA); // in grid cell

  printf("\n(dgx, dgy, dgtheta) = (%lf, %lf, %lf)\n", dgx, dgy, dgtheta);
  printf("(gx, gy, gtheta) = (%d, %d, %d)\n", gx, gy, gtheta);

  /////////for debug/////////
  //gx = 96; gy = 25;
  //dgx = 9.62; dgy = 2.557;
  //dgtheta = 1.512;
  //gtheta = (int)(dgtheta/THETA);
  ///////////////////////////


  /* goal range is about 1m square */
  for (i = gy-5; i < gy+5; i++){
    for (j = gx-5; j < gx+5; j++){
      for (k = 0; k < SIZE_T; k++){
	map[i][j][k].goal = true;
      }
    }
  }

  if (Collide(tfpoint.getX(), tfpoint.getY(), tfyaw)){
    std::cout << "INVALID GOAL POINT!" << std::endl;
    return;
  }

  /* Set WaveFront heurisic */
  WaveFrontInit();

  _goal_set = true;
}
示例#4
0
/* Cleaning up a list with pending timers. */
void destruction_test(void) {
  grpc_timer timers[5];
  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;

  grpc_timer_list_init(gpr_time_0(GPR_CLOCK_REALTIME));
  memset(cb_called, 0, sizeof(cb_called));

  grpc_timer_init(&exec_ctx, &timers[0], tfm(100), cb, (void *)(intptr_t)0,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  grpc_timer_init(&exec_ctx, &timers[1], tfm(3), cb, (void *)(intptr_t)1,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  grpc_timer_init(&exec_ctx, &timers[2], tfm(100), cb, (void *)(intptr_t)2,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  grpc_timer_init(&exec_ctx, &timers[3], tfm(3), cb, (void *)(intptr_t)3,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  grpc_timer_init(&exec_ctx, &timers[4], tfm(1), cb, (void *)(intptr_t)4,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  GPR_ASSERT(1 == grpc_timer_check(&exec_ctx, tfm(2), NULL));
  grpc_exec_ctx_finish(&exec_ctx);
  GPR_ASSERT(1 == cb_called[4][1]);
  grpc_timer_cancel(&exec_ctx, &timers[0]);
  grpc_timer_cancel(&exec_ctx, &timers[3]);
  grpc_exec_ctx_finish(&exec_ctx);
  GPR_ASSERT(1 == cb_called[0][0]);
  GPR_ASSERT(1 == cb_called[3][0]);

  grpc_timer_list_shutdown(&exec_ctx);
  grpc_exec_ctx_finish(&exec_ctx);
  GPR_ASSERT(1 == cb_called[1][0]);
  GPR_ASSERT(1 == cb_called[2][0]);
}
示例#5
0
/* Cleaning up a list with pending alarms. */
void destruction_test(void) {
  grpc_alarm alarms[5];

  grpc_alarm_list_init(gpr_time_0(GPR_CLOCK_REALTIME));
  memset(cb_called, 0, sizeof(cb_called));

  grpc_alarm_init(&alarms[0], tfm(100), cb, (void *)(gpr_intptr)0,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  grpc_alarm_init(&alarms[1], tfm(3), cb, (void *)(gpr_intptr)1,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  grpc_alarm_init(&alarms[2], tfm(100), cb, (void *)(gpr_intptr)2,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  grpc_alarm_init(&alarms[3], tfm(3), cb, (void *)(gpr_intptr)3,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  grpc_alarm_init(&alarms[4], tfm(1), cb, (void *)(gpr_intptr)4,
                  gpr_time_0(GPR_CLOCK_REALTIME));
  GPR_ASSERT(1 == grpc_alarm_check(NULL, tfm(2), NULL));
  GPR_ASSERT(1 == cb_called[4][1]);
  grpc_alarm_cancel(&alarms[0]);
  grpc_alarm_cancel(&alarms[3]);
  GPR_ASSERT(1 == cb_called[0][0]);
  GPR_ASSERT(1 == cb_called[3][0]);

  grpc_alarm_list_shutdown();
  GPR_ASSERT(1 == cb_called[1][0]);
  GPR_ASSERT(1 == cb_called[2][0]);
}
示例#6
0
inline bool const merge_sort(char     const *in,
                             char     const *out,
                             unsigned const  offset,
                             unsigned const  max_lines = 1000000)
{
    std::deque<std::string>         temporary_files;
    detail::temporary_file_manager<
        std::deque<std::string> >   tfm(temporary_files);
    
    std::ifstream infile(in, std::ios_base::in | std::ios_base::binary);
    if (!infile.is_open())
    {
        std::ostringstream err;
        err << "Unable to open file " << in;
        BOOST_THROW_EXCEPTION(std::runtime_error(err.str()));
    }

    while (!infile.eof())
    {
        typedef std::map<boost::shared_ptr<std::string>, unsigned, detail::key_offset_compare> lines_t;
        detail::key_offset_compare map_comparator(offset);
        lines_t lines(map_comparator);

        for (unsigned loop=0; !infile.eof()  &&  loop<max_lines; ++loop)
        {
            if (infile.fail()  ||  infile.bad())
                BOOST_THROW_EXCEPTION(std::runtime_error("An error occurred reading the input file."));

            boost::shared_ptr<std::string> line(new std::string);
            std::getline(infile, *line);

            ++lines.insert(std::make_pair(line,0U)).first->second;
        }

        std::string const temp_filename(platform::get_temporary_filename());
        temporary_files.push_back(temp_filename);
        std::ofstream file(temp_filename.c_str(), std::ios_base::out | std::ios_base::binary);
        for (lines_t::const_iterator it=lines.begin(); it!=lines.end(); ++it)
        {
            if (file.fail()  ||  file.bad())
                BOOST_THROW_EXCEPTION(std::runtime_error("An error occurred writing temporary a file."));

            for (unsigned loop=0; loop<it->second; ++loop)
                file << *(it->first);
            file << "\n";
        }
    }
    infile.close();
    detail::do_file_merge(temporary_files.begin(), temporary_files.end(), out, offset);

	return true;
}
示例#7
0
  void Navigation::
  parse (::xsd::cxx::xml::dom::parser< char >& p,
         ::xml_schema::Flags f)
  {
    for (; p.more_elements (); p.next_element ())
    {
      const ::xercesc::DOMElement& i (p.cur_element ());
      const ::xsd::cxx::xml::qualified_name< char > n (
        ::xsd::cxx::xml::dom::name< char > (i));

      // event
      //
      {
        ::xsd::cxx::tree::type_factory_map< char >& tfm (
          ::xsd::cxx::tree::type_factory_map_instance< 0, char > ());

        ::std::auto_ptr< ::xsd::cxx::tree::type > tmp (
          tfm.create (
            "event",
            "artofsequence.org/aosl/1.0",
            &::xsd::cxx::tree::factory_impl< EventType >,
            true, true, i, n, f, this));

        if (tmp.get () != 0)
        {
          ::std::auto_ptr< EventType > r (
            dynamic_cast< EventType* > (tmp.get ()));

          if (r.get ())
            tmp.release ();
          else
            throw ::xsd::cxx::tree::not_derived< char > ();

          this->event_.push_back (r);
          continue;
        }
      }

      break;
    }
  }
示例#8
0
    void paint(QPainter* painter, const QStyleOptionViewItem& option, const QModelIndex& index) const
    {
        QStyleOptionViewItem newOption;
        newOption = option;
        newOption.state &= ~QStyle::State_HasFocus;
        newOption.palette.setColor( QPalette::Disabled, QPalette::Text, Qt::black );

        QTableWidget* pWidget = static_cast<QTableWidget*>( parent() );
        RecentTableWidgetItem* pItem = static_cast<RecentTableWidgetItem*>(pWidget->item(index.row(), index.column()));

        painter->setFont(fontTitle);
        QFontMetrics tfm(fontTitle);
        int fontTitleSize = tfm.height();
        QRect titleRect( newOption.rect.x(), newOption.rect.y(), newOption.rect.width(), fontTitleSize );
        painter->drawText( titleRect, Qt::TextSingleLine, tfm.elidedText(pItem->title, Qt::ElideRight, newOption.rect.width() ));

        painter->setFont(fontInfo);
        QFontMetrics ifm(fontInfo);
        int fontAuthorSize = ifm.height();
        QRect infoRect( newOption.rect.x(), newOption.rect.y() + fontTitleSize, newOption.rect.width(), fontAuthorSize );

        int percentWidth = ifm.boundingRect(pItem->percent).width();
        infoRect.adjust(0,0,-percentWidth,0);

        painter->drawText( infoRect, Qt::TextSingleLine, ifm.elidedText(pItem->info, Qt::ElideRight, infoRect.width() ) );

        QRect percentRect( infoRect.right(), infoRect.top(), percentWidth, infoRect.height() );
        painter->drawText( percentRect, Qt::TextSingleLine, pItem->percent );

        if (index.flags() & Qt::ItemIsSelectable)
        {
            Qt::GlobalColor lineColor = Qt::black;
            int lineWidth = newOption.state & QStyle::State_Selected ? 5:0;
            QPen pen(lineColor, lineWidth, Qt::SolidLine);
            painter->setPen(pen);
            painter->drawLine(newOption.rect.left(), newOption.rect.bottom()-lineWidth/2, newOption.rect.right(), newOption.rect.bottom()-lineWidth/2);
        }
    }
示例#9
0
void StartCallback(const geometry_msgs::PoseWithCovarianceStampedConstPtr &msg)
{
  ros::NodeHandle n;
  geometry_msgs::PoseStamped posestamped;
  double roll, pitch, yaw, tfyaw;

  tf::Vector3 tfpoint = TransformPoint(msg->pose.pose);

  sx = (int)(tfpoint.getX()*10);
  sy = (int)(tfpoint.getY()*10);
  dsx = msg->pose.pose.position.x;
  dsy = msg->pose.pose.position.y;

  tf::Quaternion quat(msg->pose.pose.orientation.x, msg->pose.pose.orientation.y,
		      msg->pose.pose.orientation.z, msg->pose.pose.orientation.w);
  tf::Matrix3x3 m(quat);
  m.getRPY(roll, pitch, yaw);
  dstheta = yaw; // in real world

  tf::Quaternion tfquat = _transform * quat;
  tf::Matrix3x3 tfm(tfquat);
  tfm.getRPY(roll, pitch, tfyaw);
  if (tfyaw < 0) {tfyaw+=2*M_PI;} //make yaw 0~2PI
  stheta = (int)(tfyaw/THETA);  //0~23 (THETA=PI/12) in grid cell

  printf("\n(dsx, dsy, dstheta) = (%lf, %lf, %lf)\n", dsx, dsy, dstheta);
  printf("(sx, sy, stheta) = (%d, %d, %d)\n", sx, sy, stheta);

  ros::Publisher start_pub = n.advertise<geometry_msgs::PoseStamped>("start_pose", 1000, true);

  /* for start pose visualization */
  posestamped.header.frame_id = PATH_FRAME;
  posestamped.pose.position.x = dsx;
  posestamped.pose.position.y = dsy;
  posestamped.pose.position.z = 0.0;
  posestamped.pose.orientation.x = msg->pose.pose.orientation.x;
  posestamped.pose.orientation.y = msg->pose.pose.orientation.y;
  posestamped.pose.orientation.z = msg->pose.pose.orientation.z;
  posestamped.pose.orientation.w = msg->pose.pose.orientation.w;

  start_pub.publish(posestamped);
  /********************************/

  /*Collision detection of start point */
  if (Collide(tfpoint.getX(), tfpoint.getY(), tfyaw)){
    std::cout << "INVALID START POINT!" << std::endl;
    return;
  }


  /* set start point */
  map[sy][sx][stheta].status = OPEN;
  map[sy][sx][stheta].x = dsx;  map[sy][sx][stheta].y = dsy;
  map[sy][sx][stheta].theta = dstheta;
  map[sy][sx][stheta].gc = 0.0;
  map[sy][sx][stheta].parent = NULL;

  /* push start point to openlist */
  openlist.push(map[sy][sx][stheta]);

  /* set start point to current point */
  current_x = map[sy][sx][stheta].x;  current_y = map[sy][sx][stheta].y;
  current_theta = map[sy][sx][stheta].theta;


  _start_set = true;
}
示例#10
0
RecentBooksDlg::RecentBooksDlg(QWidget *parent, CR3View * docView )
    : Dialog(parent)
    , ui(new Ui::RecentBooksDlg)
    , docview(docView)
{
    ui->setupUi(this);

    QFont f(ui->tableWidget->font());
    f.setPointSize(docview->getOptions()->getIntDef("cr3.app.ui.recent.font.size", 12));
    ui->tableWidget->setFont(f);

    f = ui->lblPosition->font();
    f.setPointSize(f.pointSize()/2);
    ui->lblPosition->setFont(f);

    f = ui->lblTitle->font();
    f.setBold(true);
    ui->lblTitle->setFont(f);

    ui->tableWidget->setColumnCount(1);

    ui->tableWidget->horizontalHeader()->setResizeMode(0, QHeaderView::Stretch);
    ui->tableWidget->horizontalHeader()->setResizeMode(1, QHeaderView::ResizeToContents);
    ui->tableWidget->verticalHeader()->setResizeMode(QHeaderView::Custom);

    bool isVscroll = docview->getOptions()->getIntDef(PROP_APP_UI_RECENT_VSCROLLBAR, 1) != 0;
    ui->tableWidget->setVerticalScrollBarPolicy(isVscroll? Qt::ScrollBarAsNeeded : Qt::ScrollBarAlwaysOff);
    bool isHscroll = docview->getOptions()->getIntDef(PROP_APP_UI_RECENT_HSCROLLBAR, 1) != 0;
    ui->tableWidget->setHorizontalScrollBarPolicy(isHscroll? Qt::ScrollBarAsNeeded : Qt::ScrollBarAlwaysOff);

    // fill rows
    QFont fontTitle = ui->tableWidget->font();
    fontTitle.setBold(true);

    QFont fontAuthor = ui->tableWidget->font();
    fontAuthor.setItalic(true);

    QFont fontInfo = ui->tableWidget->font();
    fontInfo.setItalic(true);
    fontInfo.setPointSize(fontInfo.pointSize()*2/3);

    QFontMetrics tfm(fontTitle);
    QFontMetrics afm(fontAuthor);

    int rowHeight = tfm.height() + afm.height();
    ui->tableWidget->verticalHeader()->setResizeMode(QHeaderView::Fixed);
    ui->tableWidget->verticalHeader()->setDefaultSectionSize(rowHeight);

    ui->tableWidget->setItemDelegate(new RecentBooksListDelegate(ui->tableWidget, fontTitle, fontAuthor));

    LVPtrVector<CRFileHistRecord>& files = docview->getDocView()->getHistory()->getRecords();

    // remove non-existing entries
    for( int k=0; k<files.length(); )
    {
        QString fn(cr2qt(files.get(k)->getFilePathName()));
        if (!QFile::exists(fn))
            files.remove(k);
        else
            ++k;
    }

    ui->tableWidget->setRowCount( files.length() );

    // insert items
    for( int index=0; index<files.length(); ++index )
    {
        CRFileHistRecord* book = files.get(index);

        RecentTableWidgetItem* titleItem = new RecentTableWidgetItem();
        titleItem->title   = cr2qt(book->getTitle());
        if ( titleItem->title.isEmpty() )
            titleItem->title = cr2qt(book->getFileName());
        titleItem->info  = cr2qt(book->getAuthor());
        if ( titleItem->info.isEmpty() )
            titleItem->info = "-";
        titleItem->percent = " " + crpercent(book->getLastPos()->getPercent());

        ui->tableWidget->setItem(index, 0, titleItem);
    }

    ui->navBar->setControls(ui->tableWidget, ui->lblPosition,
                            QSize( docview->getOptions()->getIntDef(PROP_APP_UI_SWIPES_X_WEIGHT, 1),
                                   docview->getOptions()->getIntDef(PROP_APP_UI_SWIPES_Y_WEIGHT, 1) ) );

    ui->tableWidget->setEditFocus(true);
    ui->tableWidget->setCurrentCell(0,0);

    QObject::connect( ui->tableWidget, SIGNAL(itemActivated(QTableWidgetItem*)), this, SLOT(onClicked(QTableWidgetItem*)) );
    QObject::connect( ui->tableWidget, SIGNAL(itemClicked(QTableWidgetItem*)), this, SLOT(onClicked(QTableWidgetItem*)) );

    init();
}