BOOL CHMMDemoView::OnEraseBkgnd(CDC* pDC) { CImage& img = Camera().GetFrame(); CRect ir( 0, 0, img.Width(), img.Height() ); CRect r; pDC->GetClipBox( &r ); if( ir.PtInRect( r.TopLeft()) && ir.PtInRect( r.BottomRight())) return TRUE; return CView::OnEraseBkgnd(pDC); }
void CMainWindow::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) { if(nSBCode==8) return; int tmp_pos=nPos; if(nSBCode==3){ tmp_pos=pScrollBar->GetScrollPos()+m_vscroll_page_size-2*NETWORKCELLHEIGHT; } else if(nSBCode==2){ tmp_pos=pScrollBar->GetScrollPos()-(m_vscroll_page_size-2*NETWORKCELLHEIGHT); } tmp_pos=max(0,tmp_pos); tmp_pos=min(tmp_pos,pScrollBar->GetScrollLimit()); nPos=tmp_pos; m_vscroll_pos=nPos; //invalidate the part of the screen that may change CRect client_rect; this->GetClientRect(&client_rect); CRect ir(0,0,350,client_rect.bottom-0); this->InvalidateRect(&ir,TRUE); pScrollBar->SetScrollPos(nPos,TRUE); this->SetFocus(); }
void FilteredImage::setSource(const QString &source) { if(m_source != source) { m_source = source; QImageReader ir(m_source); QByteArray format(ir.format()); m_image = ir.read(); NemoImageMetadata meta(m_source, format); if (meta.orientation() != NemoImageMetadata::TopLeft) { m_image = rotate(m_image, meta.orientation()); } setImplicitWidth((qreal)m_image.width()); setImplicitHeight((qreal)m_image.height()); m_imageChanged = true; emit sourceChanged(m_source); emit imageChanged(m_image); } }
void AISTargetQueryDialog::UpdateText() { wxString html; if( !m_pQueryTextCtl ) return; DimeControl( this ); wxColor bg = GetBackgroundColour(); m_pQueryTextCtl->SetBackgroundColour( bg ); SetBackgroundColour( bg ); // if( m_MMSI == 0 ) { // Faulty MMSI could be reported as 0 AIS_Target_Data *td = g_pAIS->Get_Target_Data_From_MMSI( m_MMSI ); if( td ) { if( td->b_PersistTrack ) { m_createTrkBtn->SetLabel(_("Stop Tracking")); } else { m_createTrkBtn->SetLabel(_("Record Track")); } wxFont *dFont = FontMgr::Get().GetFont( _("AISTargetQuery") ); wxString face = dFont->GetFaceName(); int sizes[7]; for( int i=-2; i<5; i++ ) { sizes[i+2] = dFont->GetPointSize() + i + (i>0?i:0); } html.Printf( _T("<html><body bgcolor=#%02x%02x%02x><center>"), bg.Red(), bg.Green(), bg.Blue() ); html << td->BuildQueryResult(); html << _T("</center></font></body></html>"); m_pQueryTextCtl->SetFonts( face, face, sizes ); m_pQueryTextCtl->SetPage( html ); // Try to create a min size that works across font sizes. wxSize sz; if( ! IsShown() ) { sz = m_pQueryTextCtl->GetVirtualSize(); sz.x = 300; m_pQueryTextCtl->SetSize( sz ); } m_pQueryTextCtl->Layout(); wxSize ir(m_pQueryTextCtl->GetInternalRepresentation()->GetWidth(), m_pQueryTextCtl->GetInternalRepresentation()->GetHeight() ); sz.x = wxMax( m_pQueryTextCtl->GetSize().x, ir.x ); sz.y = wxMax( m_pQueryTextCtl->GetSize().y, ir.y ); m_pQueryTextCtl->SetMinSize( sz ); Fit(); sz -= wxSize( 200, 200 ); m_pQueryTextCtl->SetMinSize( sz ); m_createWptBtn->Enable( td->b_positionOnceValid ); m_createTrkBtn->Enable( td->b_show_track ); } // } }
void AISTargetQueryDialog::SetBestSize( void ) { // Try to create a min size that works across font sizes. wxSize sz; /* if( ! IsShown() ) { sz = m_pQueryTextCtl->GetVirtualSize(); sz.x = 300; m_pQueryTextCtl->SetSize( sz ); } */ m_pQueryTextCtl->Layout(); wxSize ir(m_pQueryTextCtl->GetInternalRepresentation()->GetWidth(), m_pQueryTextCtl->GetInternalRepresentation()->GetHeight() ); sz.x = wxMax( m_pQueryTextCtl->GetSize().x, ir.x ); sz.y = wxMax( m_pQueryTextCtl->GetSize().y, ir.y ); sz.x += 100; // fluff, to try and avoid scrollbars sz.y += 20; // fluff m_pQueryTextCtl->SetMinSize( sz ); Fit(); sz -= wxSize( 200, 200 ); m_pQueryTextCtl->SetMinSize( sz ); }
hrCacheItem* hrCache::Load(const QString &name) const { hrCacheItem *item = new hrCacheItem(); QImageReader ir("vfs:/" + name); QImage im; if (ir.read(&im)) { item->addFrame(Load(im)); } for (int i = 1; ir.jumpToImage(i); i++) if (ir.read(&im)) { item->addFrame(Load(im)); } item->setSize(im.size()); if (ir.error()) { qFatal("hrCache: %s", qPrintable(ir.errorString() + name)); } return item; }
void TensorDerivative(Mode m, Mode mj, Geometry geo, Vec df, Vec vpsibra, Vec vIpsi, int ih){ double mjc = get_c(mj); dcomp mw = get_w(m), yw = gamma_w(m, geo) ; Vecfun f, H, psibra; CreateVecfun(&f, geo->vf); CreateVecfun(&H, geo->vH); CreateVecfun(&psibra, vpsibra); Complexfun psi; CreateComplexfun(&psi, m->vpsi, vIpsi); int i; for(i=f.ns; i<f.ne; i++){ if( valr(&f, i) == 0.0) continue; dcomp ket_term = -csqr(mw ) * sqr(mjc) * 2.0 * sqr(valr(&H, i) ) * geo->D * valr(&f, i) * yw * valc(&psi, i); double val = valr(&psibra, i) * (ir(geo, i)? cimag(ket_term) : creal(ket_term) ); VecSetValue(df, i+offset(geo, ih), val, INSERT_VALUES); // df is assembled in SetJacobian } DestroyVecfun(&f); DestroyVecfun(&H); DestroyVecfun(&psibra); DestroyComplexfun(&psi); }
HBITMAP imageFromSelection(Frame* frame, bool forceBlackText) { frame->view()->setPaintRestriction(forceBlackText ? PaintRestrictionSelectionOnlyBlackText : PaintRestrictionSelectionOnly); FloatRect fr = frame->selectionRect(); IntRect ir(static_cast<int>(fr.x()), static_cast<int>(fr.y()), static_cast<int>(fr.width()), static_cast<int>(fr.height())); void* bits; HDC hdc = CreateCompatibleDC(0); int w = ir.width(); int h = ir.height(); BITMAPINFO bmp = { { sizeof(BITMAPINFOHEADER), w, h, 1, 32 } }; HBITMAP hbmp = CreateDIBSection(0, &bmp, DIB_RGB_COLORS, static_cast<void**>(&bits), 0, 0); HBITMAP hbmpOld = static_cast<HBITMAP>(SelectObject(hdc, hbmp)); CGColorSpaceRef deviceRGB = CGColorSpaceCreateDeviceRGB(); CGContextRef context = CGBitmapContextCreate(static_cast<void*>(bits), w, h, 8, w * sizeof(RGBQUAD), deviceRGB, kCGBitmapByteOrder32Little | kCGImageAlphaPremultipliedFirst); CGColorSpaceRelease(deviceRGB); CGContextSaveGState(context); GraphicsContext gc(context); frame->document()->updateLayout(); drawRectIntoContext(ir, frame->view(), &gc); CGContextRelease(context); SelectObject(hdc, hbmpOld); DeleteDC(hdc); frame->view()->setPaintRestriction(PaintRestrictionNone); return hbmp; }
int main (int argc, const char* argv[] ) { ucam::util::initLogger ( argc, argv ); FORCELINFO ( argv[0] << " starts!" ); ucam::util::RegistryPO rg ( argc, argv ); FORCELINFO ( rg.dump ( "CONFIG parameters:\n=====================", "=====================" ) ) ; ucam::util::PatternAddress<unsigned> pi (rg.get<std::string> (HifstConstants::kInput) ); ucam::util::PatternAddress<unsigned> po (rg.get<std::string> (HifstConstants::kOutput) ); for ( ucam::util::IntRangePtr ir (ucam::util::IntRangeFactory ( rg, HifstConstants::kRangeOne ) ); !ir->done(); ir->next() ) { fst::VectorFst<fst::StdArc> *mfst = fst::VectorFstRead<fst::StdArc> (pi ( ir->get() ) ); if (!mfst) return 1; TopSort (mfst); boost::multiprecision::uint128_t j = countstrings<fst::StdArc, boost::multiprecision::uint128_t> (*mfst); std::stringstream ss; ss << j; ucam::util::oszfstream o (po (ir->get() ), true); o << ss.str() << std::endl; LINFO ( pi (ir->get() ) << ":" << ss.str() ) ; o.close(); delete mfst; } FORCELINFO ( argv[0] << " ends!" ); }
void run(ucam::util::RegistryPO const &rg) { ucam::util::PatternAddress<unsigned> pi (rg.get<std::string> (HifstConstants::kInput) ); ucam::util::PatternAddress<unsigned> po (rg.get<std::string> (HifstConstants::kOutput) ); for ( ucam::util::IntRangePtr ir (ucam::util::IntRangeFactory ( rg, HifstConstants::kRangeOne ) ); !ir->done(); ir->next() ) { fst::VectorFst<Arc> *mfst = fst::VectorFstRead<Arc> (pi ( ir->get() ) ); if (!mfst) { LERROR("Could not read file:" << ir->get()); exit(EXIT_FAILURE); } TopSort (mfst); boost::multiprecision::uint128_t j = countstrings<Arc, boost::multiprecision::uint128_t> (*mfst); std::stringstream ss; ss << j; ucam::util::oszfstream o (po (ir->get() ), true); o << ss.str() << std::endl; LINFO ( pi (ir->get() ) << ":" << ss.str() ) ; o.close(); delete mfst; } }
// Add preheader and loop exit blocks; after this pass, // dominators are not valid anymore void LoopFinder::insert_blocks(LoopList* loops) { if (LIRCacheLocals) { intStack* tags = new intStack(max_blocks(), -1); int i; for (i = 0; i < loops->length(); i++) { Tagger t(tags, i); loops->at(i)->blocks()->iterate_forward(&t); } PairCollector pc(tags); ir()->iterate_preorder(&pc); BlockPairList* pairs = pc.pairs(); pairs->sort(sort_by_block_ids); BlockPair* last_pair = NULL; for (i = 0; i < pairs->length(); i++) { BlockPair* p = pairs->at(i); if (last_pair != NULL && p->is_same(last_pair)) { // last_pair is not null and p is same as last_pair -> skip inserting of blocks } else { insert_caching_block(loops, p->from(), p->to()); last_pair = p; } } } }
void Lidar:: StepUpdate(const Line & line) { double phi(m_global_pose->Theta() + phi0); double const dphi(phirange / (nscans - 1)); Ray ray(m_global_pose->X(), m_global_pose->Y(), phi); for(size_t ir(0); ir < nscans; ++ir){ const double true_rr(ray.Intersect(line)); if((true_rr > 0) && (true_rr < m_true_rho[ir])){ m_true_rho[ir] = true_rr; if( ! m_noise_model) m_noisy_rho[ir] = true_rr; } if(m_noise_model){ const double noisy_rr((*m_noise_model)(true_rr)); if((noisy_rr > 0) && (noisy_rr < m_noisy_rho[ir])) m_noisy_rho[ir] = noisy_rr; } phi += dphi; ray.SetAngle(phi); } }
int main(int argc, char **argv) { ros::init (argc, argv, "PhidgetsIR"); ros::NodeHandle nh; ros::NodeHandle nh_private("~"); phidgets::IRRosI ir(nh, nh_private); ros::spin(); return 0; }
void process_line(const std::string& line, T& dest) { csv_separator sep; Tokenizer tok(line, sep); Tokenizer::iterator s = tok.begin(); ItemWalker ir(s, tok.end()); tuple_for_each(ir, dest); }
void plugin_load(char *filename, option_block *opts) { plugin_init ir; char fileline[8192] = {0}; int length = strcspn(filename+1, " \n\r"); if( length > 8191 ) { file_error("filename for plugin is too large!", opts); return; } strncpy(fileline, filename+1, length); if( plugin_handle != NULL ) { file_error("limit 1 plugin per script!", opts); return; } plugin_handle = sfuzz_dlopen(fileline, RTLD_NOW); if(plugin_handle == NULL) { file_error("Unable to open plugin (check the search path?).", opts); return; } ir = (plugin_init)dlsym(plugin_handle, "plugin_init"); if(ir == NULL) { fprintf(stderr, "--- plugin loading: [%s][%s] ---\n", fileline, dlerror()); file_error("unable to locate entrypoint in plugin", opts); return; } g_plugin = (plugin_provisor*)malloc(sizeof(plugin_provisor)); if(g_plugin == NULL) { file_error("unable to allocate plugin descriptor", opts); return; } memset(g_plugin, 0, sizeof(plugin_provisor)); ir(g_plugin); if(g_plugin->name == NULL || g_plugin->version == NULL) { file_error("plugin is invalid!", opts); return; } plugin_sanity(opts); }
tgt::ivec3 Flow3D::getNearestVoxelPos(const tgt::vec3& r) const { tgt::ivec3 ir(0, 0, 0); for (size_t i = 0; i < 3; ++i) { //ir[i] = (r[i] <= 0.0f) ? 0 : static_cast<int>(r[i]);// cut off fractional part (floor) ir[i] = (r[i] <= 0.0f) ? 0 : static_cast<int>((r[i] + 0.5f)); if (ir[i] >= dimensions_[i]) ir[i] = (dimensions_[i] - 1); } return ir; }
tgt::ivec3 Flow3D::clampToFlowDimensions(const tgt::ivec3& r) const { tgt::ivec3 ir(r); for (size_t i = 0; i < 3; ++i) { if (ir[i] < 0) ir[i] = 0; else if (ir[i] >= dimensions_[i]) ir[i] = (dimensions_[i] - 1); } return ir; }
void Lidar:: InitUpdate() { *m_global_pose = *mount; owner->GetPose().To(*m_global_pose); for(size_t ir(0); ir < nscans; ++ir){ m_true_rho[ir] = rhomax; m_noisy_rho[ir] = rhomax; } }
QImage NemoThumbnailProvider::generateThumbnail(const QString &id, const QByteArray &hashData, const QSize &requestedSize, bool crop) { QImage img; QSize originalSize; QByteArray format; // image was not in cache thus we read it QImageReader ir(id); if (!ir.canRead()) return img; originalSize = ir.size(); format = ir.format(); if (originalSize != requestedSize && originalSize.isValid()) { if (crop) { // scales arbitrary sized source image to requested size scaling either up or down // keeping aspect ratio of the original image intact by maximizing either width or height // and cropping the rest of the image away QSize scaledSize(originalSize); // now scale it filling the original rectangle by keeping aspect ratio, but expand if needed. scaledSize.scale(requestedSize, Qt::KeepAspectRatioByExpanding); // set the adjusted clipping rectangle in the center of the scaled image QPoint center((scaledSize.width() - 1) / 2, (scaledSize.height() - 1) / 2); QRect cr(0,0,requestedSize.width(), requestedSize.height()); cr.moveCenter(center); ir.setScaledClipRect(cr); // set requested target size of a thumbnail ir.setScaledSize(scaledSize); } else { // Maintains correct aspect ratio without cropping, as such the final image may // be smaller than requested in one dimension. QSize scaledSize(originalSize); scaledSize.scale(requestedSize, Qt::KeepAspectRatio); ir.setScaledSize(scaledSize); } } img = ir.read(); NemoImageMetadata meta(id, format); if (meta.orientation() != NemoImageMetadata::TopLeft) img = rotate(img, meta.orientation()); // write the scaled image to cache if (meta.orientation() != NemoImageMetadata::TopLeft || (originalSize != requestedSize && originalSize.isValid())) { writeCacheFile(hashData, img); } TDEBUG() << Q_FUNC_INFO << "Wrote " << id << " to cache"; return img; }
void LIR_OopMapGenerator::clear_all(int local_name) { // Have to clear out all slots corresponding to this local name WordSizeList* name_to_offset_map = ir()->local_name_to_offset_map(); WordSize offset = name_to_offset_map->at(local_name); for (int i = 0; i < name_to_offset_map->length(); i++) { WordSize word = name_to_offset_map->at(i); if (word == offset) { clear(i); } } }
HBITMAP imageFromSelection(Frame* frame, bool forceBlackText) { frame->document()->updateLayout(); frame->view()->setPaintBehavior(PaintBehaviorSelectionOnly | (forceBlackText ? PaintBehaviorForceBlackText : 0)); FloatRect fr = frame->selection()->bounds(); IntRect ir(static_cast<int>(fr.x()), static_cast<int>(fr.y()), static_cast<int>(fr.width()), static_cast<int>(fr.height())); HBITMAP image = imageFromRect(frame, ir); frame->view()->setPaintBehavior(PaintBehaviorNormal); return image; }
void CHMMDemoView::CheckUpdate() { m_sel = NormalizeRect( m_tmp_sel ); if( !Camera().IsRunning() ) { CImage& img = Camera().GetFrame(); CRect ir( 0, 0, img.Width(), img.Height() ); InvalidateRect(&ir, FALSE); UpdateWindow(); } }
/* Calculates the element matrix. Input is: the finite element: fel the geometry of the element: eltrans Output is: the element matrix: elmat Efficient memorymanagement is provided my locheap */ void MyLaplaceIntegrator :: CalcElementMatrix (const FiniteElement & base_fel, const ElementTransformation & eltrans, FlatMatrix<double> elmat, LocalHeap & lh) const { /* tell the compiler that we are expecting to get an scalar fe in 2D. if not, an exception will be raised */ const ScalarFiniteElement<2> & fel = dynamic_cast<const ScalarFiniteElement<2> &> (base_fel); // number of element basis functions: int ndof = fel.GetNDof(); elmat = 0; Matrix<> dshape_ref(ndof, 2); // gradient on reference element Matrix<> dshape(ndof, 2); // gradient on mapped element /* get integration rule for element geometry, integration order is 2 times element order */ IntegrationRule ir(fel.ElementType(), 2*fel.Order()); // loop over integration points for (int i = 0 ; i < ir.GetNIP(); i++) { // calculate Jacobi matrix in the integration point MappedIntegrationPoint<2,2> mip(ir[i], eltrans); // lambda(x) double lam = coef_lambda -> Evaluate (mip); /* gradient on reference element the i-th row of the matrix is the grad of the i-th shape function */ fel.CalcDShape (ir[i], dshape_ref); // transform it for the mapped element dshape = dshape_ref * mip.GetJacobianInverse(); // integration weight and Jacobi determinant double fac = mip.IP().Weight() * mip.GetMeasure(); // elmat_{i,j} += (fac*lam) * InnerProduct (grad shape_i, grad shape_j) elmat += (fac*lam) * dshape * Trans(dshape); } }
int main() { Object object; int n = object.faces.size(); object.load("test_data/block.obj"); object.meshSimplify(10000, false); return 0; RenderSetting rs("renderconfig2/render.cfg"); ImageRenderer ir(&rs); ir.renderImage(); return 0; }
void LIR_OopMapGenerator::generate() { // Initialize by iterating down the method's signature and marking // oop locals in the state assert((int) oop_map()->size() == frame_map()->num_local_names(), "just checking"); oop_map()->clear(); ciSignature* sig = ir()->method()->signature(); int idx = 0; // Handle receiver for non-static methods if (!ir()->method()->is_static()) { mark(frame_map()->name_for_argument(idx)); ++idx; } for (int i = 0; i < sig->count(); i++) { ciType* type = sig->type_at(i); if (!type->is_primitive_type()) { mark(frame_map()->name_for_argument(idx)); } idx += type->size(); } // The start block contains a Base instruction, which causes the LIR // for ref-uninit conflicts to be generated. We need to handle this // block specially so we don't traverse its "osr_entry" successor, // because we don't know how to set up the state appropriately for // that entry point. _base = ir()->start()->end()->as_Base(); // Always start iterating at the start (even for OSR compiles) merge_state(ir()->start()); BlockBegin* block = work_list_dequeue(); while (block != NULL) { oop_map()->set_from(*block->lir_oop_map()); iterate_one(block); block = work_list_dequeue(); } }
int main(int argc, char const* argv[]) { iRemoconClient ir("192.168.0.3", 51013); Interpreter ip; if (!ip.learn_commands_from_xml("data/commands.xml")) { std::cerr << "Error: XML is invalid" << std::endl; } JuliusClient jc("192.168.0.10", 10500); jc.connect(ip, ir); return 0; }
void DGFiniteElement<D>:: GetDiagMassMatrix (FlatVector<> mass) const { #ifndef __CUDA_ARCH__ IntegrationRule ir(this->ElementType(), 2*order); VectorMem<50> shape(ndof); mass = 0; for (int i = 0; i < ir.Size(); i++) { this -> CalcShape (ir[i], shape); for (int j = 0; j < ndof; j++) mass(j) += ir[i].Weight() * sqr (shape(j)); } #endif }
bool TImageReader::load(const TFilePath &path, TRasterP &raster) { raster = TRasterP(); TImageReaderP ir(path); if (!ir) return false; TImageP img = ir->load(); if (!img) return false; TRasterImageP ri(img); if (!ri) return false; raster = ri->getRaster(); return true; }
int main() { eventReceiver receiver; IrrlichtDevice *device = createDevice( video::EDT_OPENGL, dimension2d<u32>(1366, 768), 16,true, false, false,&receiver); device->setWindowCaption(L"(WhizGeek || Mclightning).com"); IVideoDriver* driver = device->getVideoDriver(); ISceneManager* smgr = device->getSceneManager(); scene::ICameraSceneNode* kam= smgr->addCameraSceneNode(NULL,vector3df(0,0,200),vector3df(0,0,0)); //kam->setPosition(vector3df(0,0,200)); ISceneNode* kutu=smgr->addCubeSceneNode(50,0,2,vector3df(50,0,0)); ISceneNode* kutu2=smgr->addCubeSceneNode(50,0,2,vector3df(-50,0,0)); ITexture *duvar=driver->getTexture("wall.jpg"); kutu->setMaterialTexture(0,duvar); kutu->setMaterialFlag(video::EMF_LIGHTING, false); kutu2->setMaterialTexture(0,duvar); kutu2->setMaterialFlag(video::EMF_LIGHTING, false); IAnimatedMesh* mesh = smgr->getMesh("sydney.md2"); IAnimatedMeshSceneNode* node = smgr->addAnimatedMeshSceneNode( mesh ); node->setMaterialFlag(EMF_LIGHTING, false); node->setMD2Animation(scene::EMAT_STAND); node->setMaterialTexture( 0, driver->getTexture("sydney.bmp") ); node->setRotation(vector3df(0,270,0)); irFinder ir("test",true,230,255); CvPoint in; while(device->run()) { if(receiver.IsKeyDown(KEY_ESCAPE)) { device->drop(); return 0; } driver->beginScene(true, true, SColor(255,0,0,255)); in=ir.yenile(); //node->setPosition(vector3df(30*in.x/320,30*(240-in.y)/240,0)); kam->setPosition(vector3df(in.x-160,(240-in.y),200)); smgr->drawAll(); driver->endScene(); } device->drop(); }
/** \todo Removals should be done "en vrac", not one by one. Multiscanner::raw_scan_collection_t is bad because it uses the robot's pose, not each sensor's at the time of capture. */ size_t Mapper2d:: SwipedUpdate(const Frame & pose, const Multiscanner::raw_scan_collection_t & scans, double max_remove_distance, draw_callback * cb) { m_freespace_buffer.clear(); m_obstacle_buffer.clear(); m_swipe_check_buffer.clear(); swipe_cb swipe(m_swipe_check_buffer, m_freespace_buffer, *m_travmap); ssize_t const bbx0(m_travmap->grid.xbegin()); ssize_t const bbx1(m_travmap->grid.xend()); ssize_t const bby0(m_travmap->grid.ybegin()); ssize_t const bby1(m_travmap->grid.yend()); // compute sets of swiped and obstacle cells for (size_t is(0); is < scans.size(); ++is) { double const spx(scans[is]->scanner_pose.X()); double const spy(scans[is]->scanner_pose.Y()); double const spt(scans[is]->scanner_pose.Theta()); Scan::array_t const & scan_data(scans[is]->data); const index_t i0(gridframe.GlobalIndex(spx, spy)); for (size_t ir(0); ir < scan_data.size(); ++ir) { index_t const ihit(gridframe.GlobalIndex(scan_data[ir].globx, scan_data[ir].globy)); index_t iswipe; if (scan_data[ir].rho <= max_remove_distance) { // swipe up to the laser point iswipe = ihit; } else { // swipe along ray, but stop after max_remove_distance double const theta(spt + scan_data[ir].phi); iswipe = gridframe.GlobalIndex(spx + max_remove_distance * cos(theta), spy + max_remove_distance * sin(theta)); } gridframe.DrawDDALine(i0.v0, i0.v1, iswipe.v0, iswipe.v1, bbx0, bbx1, bby0, bby1, swipe); if (scan_data[ir].in_range) { // always insert them into m_obstacle_buffer, do not check // m_travmap->IsWObst(ihit.v0, ihit.v1), because otherwise // neighboring rays can erase known W-obstacles PDEBUG("in range W-obst: global %g %g index %zd %zd\n", scan_data[ir].globx, scan_data[ir].globy, ihit.v0, ihit.v1); m_obstacle_buffer.insert(ihit); } } } // remove new obstacles from swiped set (due to grid effects, it // would otherwise be possible for a later ray to erase an // obstacle seen by an earlier ray) for (index_buffer_t::const_iterator io(m_obstacle_buffer.begin()); io != m_obstacle_buffer.end(); ++io) m_freespace_buffer.erase(*io); return UpdateObstacles(&m_obstacle_buffer, false, &m_freespace_buffer, cb); }