std::vector<Vendor> VendorDAOMySQL::findVendorByName(const std::string &name) { MySQLManager::ConnectionHolder ch(MySQLManager::getInstance()); std::unique_ptr<sql::PreparedStatement> ps(ch.conn->prepareStatement(FIND_VENDOR_BY_NAME)); ps->setString(1, "%" + name + "%"); std::unique_ptr<sql::ResultSet> res(ps->executeQuery()); std::vector<Vendor> vendors; while(res->next()) { vendors.push_back(Vendor(res->getInt(1), res->getString(2))); } return vendors; }
void w_validate_buffer(window* pw, int view_w, int view_h) { if(pw->dirty_area.is_valid()) { WINDOW_ON_PAINT_PARAMS p; paint_graphics ps(pw->buffer, pw->dirty_area.x1, pw->dirty_area.y1, pw->dirty_area.x2, pw->dirty_area.y2 ); p.clip_x = pw->dirty_area.x1; p.clip_y = pw->dirty_area.y1; p.clip_w = pw->dirty_area.x2 - pw->dirty_area.x1; p.clip_h = pw->dirty_area.y2 - pw->dirty_area.y1; p.view_w = view_w; p.view_h = view_h; p.surface = &ps; pw->notify(WINDOW_ON_PAINT, &p); pw->dirty_area = agg::rect_i(1,1,0,0); } }
void Network::handlePluckerMessage(const osc::ReceivedMessage& m, const IpEndpointName& remoteEndpoint) { // Utility data structures char buffer[1024]; osc::OutboundPacketStream ps(buffer, 1024); // Parse OSC message osc::Symbol uuid; m.ArgumentStream() >> uuid >> osc::EndMessage; std::cerr << uuid << std::endl; WidgetMap* widgets = Widget::getAll(); WidgetMap::iterator wit = widgets->find(std::string(uuid)); if (wit != widgets->end() && dynamic_cast<Track*>(wit->second)) ((Track*)wit->second)->addPlucker(); }
void Function::Compile( sqlite3_context* ctx ) { Parser ps( mVM, mText ); if( ps.mErr.size() ) { mCompiled = false; vector<char> buf; ConvertToUTF8( ps.mErr, buf ); sqlite3_result_error( ctx, &buf[ 0 ], buf.size() - 1 ); } else { mCompiled = true; } }
void Network::handleObjectPadTextMessage(const osc::ReceivedMessage& m, const IpEndpointName& remoteEndpoint) { // Utility data structures char buffer[1024]; osc::OutboundPacketStream ps(buffer, 1024); // Parse OSC message osc::Symbol uuid, text; m.ArgumentStream() >> uuid >> text >> osc::EndMessage; std::cerr << uuid << ", " << text << std::endl; WidgetMap* widgets = Widget::getAll(); WidgetMap::iterator wit = widgets->find(std::string(uuid)); if (wit != widgets->end() && dynamic_cast<RoundPad*>(wit->second)) ((RoundPad*)wit->second)->setCommentText(std::string(text)); }
std::vector<Inventory> InventoryDAOMySQL::searchInventoryByGtin(const int &userId, const std::string >in) { MySQLManager::ConnectionHolder ch(MySQLManager::getInstance()); std::unique_ptr<sql::PreparedStatement> ps(ch.conn->prepareStatement(INVENTORIES_SEARCH_GTIN)); ps->setInt(1, userId); ps->setString(2, "%" + gtin + "%"); std::unique_ptr<sql::ResultSet> res(ps->executeQuery()); std::vector<Inventory> inventories; while(res->next()) { inventories.push_back(Inventory(res->getInt(1), res->getInt(2), res->getInt(3), res->getString(4))); } return inventories; }
void MergeGraphOp::setParams(const std::string params) { ParamSet ps(params); ps("color_is_vector", _color_is_vector); ps("secondary_color_is_vector", _secondary_color_is_vector); ps("texcoord_is_vector", _texcoord0_is_vector); ps("texcoord0_is_vector", _texcoord0_is_vector); ps("texcoord1_is_vector", _texcoord1_is_vector); ps("texcoord2_is_vector", _texcoord2_is_vector); ps("texcoord3_is_vector", _texcoord3_is_vector); std::string out = ps.getUnusedParams(); if(out.length()) { FWARNING(("MergeGraphOp doesn't have parameters '%s'.\n", out.c_str())); } }
HRESULT CFGFilterLAV::PropertyPageCallback(IBaseFilter* pBF) { CheckPointer(pBF, E_POINTER); CComPropertySheet ps(ResStr(IDS_PROPSHEET_PROPERTIES), AfxGetMyApp()->GetMainWnd()); // Find out which internal filter we are opening the property page for CFGFilterLAV::LAVFILTER_TYPE LAVFilterType = CFGFilterLAV::INVALID; if (!CFGFilterLAV::IsInternalInstance(pBF, &LAVFilterType)) { return E_UNEXPECTED; } HRESULT hr = E_FAIL; if (CComQIPtr<ISpecifyPropertyPages> pSPP = pBF) { ps.AddPages(pSPP, (LAVFilterType != CFGFilterLAV::AUDIO_DECODER) ? 1 : 2); } CComPtr<IPropertyPage> pPP = DEBUG_NEW CInternalPropertyPageTempl<CPinInfoWnd>(nullptr, &hr); ps.AddPage(pPP, pBF); if (ps.GetPageCount() > 1) { ps.DoModal(); if (CComQIPtr<ILAVFSettings> pLAVFSettings = pBF) { CFGFilterLAVSplitterBase::Settings settings; if (settings.GetSettings(pLAVFSettings)) { // Get current settings from LAVSplitter settings.SaveSettings(); // Save them to the registry/ini } } else if (CComQIPtr<ILAVVideoSettings> pLAVVideoSettings = pBF) { CFGFilterLAVVideo::Settings settings; if (settings.GetSettings(pLAVVideoSettings)) { // Get current settings from LAVVideo settings.SaveSettings(); // Save them to the registry/ini } } else if (CComQIPtr<ILAVAudioSettings> pLAVAudioSettings = pBF) { CFGFilterLAVAudio::Settings settings; if (settings.GetSettings(pLAVAudioSettings)) { // Get current settings from LAVAudio settings.SaveSettings(); // Save them to the registry/ini } } hr = S_OK; } return hr; }
void CXGraphBitmap::Draw(CDCEx *pDC) { if (!m_bVisible) return; CDCEx dc; BITMAP bmp; CRect bmpRect = m_clRect; if (m_bBorder) { CPenSelector ps(0, 1, pDC); pDC->Rectangle(m_clRect); bmpRect.DeflateRect (1,1,1,1); } if (pDC->m_bPrinting) pDC->AdjustRatio (bmpRect); m_pBitmap->GetBitmap(&bmp); dc.CreateCompatibleDC (pDC); CGdiObject* pOldObject = dc.SelectObject (m_pBitmap); pDC->StretchBlt(bmpRect.left, bmpRect.top, bmpRect.Width(), bmpRect.Height(), &dc, 0, 0, bmp.bmWidth, bmp.bmHeight, SRCCOPY); dc.SelectObject (pOldObject); if (m_bSizing) { if (pDC->m_bPrinting) { CRect rect = m_Tracker.m_rect; pDC->AdjustRatio (m_Tracker.m_rect); m_Tracker.Draw (pDC); m_Tracker.m_rect = rect; } else m_Tracker.Draw (pDC); } }
int main(int argc,char* argv[]) { LidarProcessOctree lpo(argv[1],512*1024*1024); #if 1 Misc::Timer t; { // BinaryPointSaver bps(argv[2]); PointCounter pc; lpo.processPoints(pc); std::cout<<pc.getNumPoints()<<std::endl; } t.elapse(); std::cout<<"Done in "<<t.getTime()*1000.0<<" ms"<<std::endl; #elif 0 PointSaver ps(argv[2]); Box box=Box::full; for(int i=0;i<2;++i) { box.min[i]=atof(argv[3+i]); box.max[i]=atof(argv[5+i]); } lpo.processPointsInBox(box,ps); #else PointCounter pc; Scalar radius=Scalar(0.1); PointDensityCalculator pdc(lpo,radius,4); #if 0 Box box; box.min=Point(930,530,0); box.max=Point(970,570,100); lpo.processPointsInBox(box,pdc); #else // lpo.processPoints(pdc); lpo.processNodesPostfix(pdc); #endif std::cout<<"Number of processed points: "<<pdc.numPoints<<std::endl; std::cout<<"Total number of found neighbors: "<<pdc.totalNumNeighbors<<std::endl; std::cout<<"Total number of loaded octree nodes: "<<lpo.getNumSubdivideCalls()<<", "<<lpo.getNumLoadedNodes()<<std::endl; std::cout<<"Average point density in 1/m^3: "<<pdc.totalNumNeighbors/(pdc.numPoints*4.0/3.0*3.141592654*radius*radius*radius)<<std::endl; #endif return 0; }
Eigen::MatrixXf powerspectrum::from_pcm(const Eigen::VectorXf& pcm_samples) { MINILOG(logTRACE) << "Powerspectrum computation. input samples=" << pcm_samples.size(); // check if inputs are sane if ((pcm_samples.size() < win_size) || (hop_size > win_size)) { return Eigen::MatrixXf(0, 0); } size_t frames = (pcm_samples.size() - (win_size-hop_size)) / hop_size; size_t freq_bins = win_size/2 + 1; // initialize power spectrum Eigen::MatrixXf ps(freq_bins, frames); // peak normalization value float pcm_scale = std::max(fabs(pcm_samples.minCoeff()), fabs(pcm_samples.maxCoeff())); // scale signal to 96db (16bit) pcm_scale = std::pow(10.0f, 96.0f/20.0f) / pcm_scale; // compute the power spectrum for (size_t i = 0; i < frames; i++) { // fill pcm for (int j = 0; j < win_size; j++) { kiss_pcm[j] = pcm_samples(i*hop_size+j) * pcm_scale * win_funct(j); } // fft kiss_fftr(kiss_status, kiss_pcm, kiss_freq); // save powerspectrum frame Eigen::MatrixXf::ColXpr psc(ps.col(i)); for (int j = 0; j < win_size/2+1; j++) { psc(j) = std::pow(kiss_freq[j].r, 2) + std::pow(kiss_freq[j].i, 2); } } MINILOG(logTRACE) << "Powerspectrum finished. size=" << ps.rows() << "x" << ps.cols(); return ps; }
void MapgenV7P::generateCaves(s16 max_stone_y, s16 large_cave_depth) { if (max_stone_y < node_min.Y) return; PseudoRandom ps(blockseed + 21343); PseudoRandom ps2(blockseed + 1032); u32 large_caves_count = (node_max.Y <= large_cave_depth) ? ps.range(0, 2) : 0; for (u32 i = 0; i < small_caves_count + large_caves_count; i++) { CavesV6 cave(ndef, &gennotify, water_level, c_water_source, c_lava_source); bool large_cave = (i >= small_caves_count); cave.makeCave(vm, node_min, node_max, &ps, &ps2, large_cave, max_stone_y, heightmap); } }
using namespace cluster int main(int argc, char* argv[]) { ClusterId num_clusters = 30; PointId num_points = 3000; Dimensions num_dimensions = 10; PointsSpace ps(num_points, num_dimensions); //std::cout << "PointSpace" << ps; Clusters clusters(num_clusters, ps); clusters.k_means(); std::cout << clusters; }
void plLayerAnimation::Read(hsStream* s, hsResMgr* mgr) { plLayerAnimationBase::Read(s, mgr); fTimeConvert.Read(s, mgr); if (!(fTimeConvert.IsStopped())) { plSynchEnabler ps(true); // enable dirty tracking so that we send state about // the anim resetting to start now. fTimeConvert.SetCurrentAnimTime(0, true); } Eval(hsTimer::GetSysSeconds(),0,0); // add sdl modifier delete fLayerSDLMod; fLayerSDLMod = new plLayerSDLModifier; fLayerSDLMod->SetLayerAnimation(this); }
bool BuildAstTreeDepGraph :: ProcessStmt( AstInterface &fa, const AstNodePtr& s) { GraphAccessInterface::Node *n = graph->CreateNodeImpl(s, GetStmtDomain(s)); StmtNodeInfo info(n,s); stmtNodes.PushFirst(info); for (StmtStackType::Iterator ps(stmtNodes); !ps.ReachEnd(); ++ps) { ComputeStmtDep((*ps), info, DEPTYPE_DATA | DEPTYPE_IO); } for ( StmtStackType::Iterator p(ctrlNodes); !p.ReachEnd(); ++p) { ComputeCtrlDep((*p), info); } for (StmtStackType::Iterator pg(gotoNodes); !pg.ReachEnd(); ++pg) { ComputeCtrlDep((*pg), info); } return ProcessAstTree::ProcessStmt(fa, s); }
int test_file(const std::string & test_data_filepath, const std::string & label_prefix) { int fails = 0; std::vector<pstrudel::TreeShape> trees; pstrudel::treeio::read_from_filepath(trees, test_data_filepath, "nexus"); unsigned long tree_idx = 0; for (auto & tree : trees) { std::string label = label_prefix + ":" + std::to_string(tree_idx + 1); pstrudel::LineageThroughTimeProfileCalculator ltt_calc(tree); auto profiles = ltt_calc.build_lineage_splitting_time_profile(); auto lst_profile = profiles.first; auto scaled_lst_profile = profiles.second; std::ostringstream o; TREE_WRITER.write(o, tree); o << "\n"; assert(lst_profile.data_size() == scaled_lst_profile.data_size()); auto rds = lst_profile.data_size(); for (unsigned long idx = 0; idx < rds; ++idx) { o << std::fixed << std::setprecision(22) << lst_profile.raw_data(idx); o << "\t" << std::fixed << std::setprecision(22) << scaled_lst_profile.raw_data(idx); o << "\n"; } colugo::Subprocess ps({"python", CHECK_SCRIPT, "-f", "newick", "-l", label}); try { auto result = ps.communicate(o.str()); if (ps.returncode() != 0) { std::cerr << "(test '" << label << "' returned error: " << ps.returncode() << ")\n"; // TREE_WRITER.write(std::cerr, tree); // std::cerr << std::endl; std::cerr << result.first; std::cerr << result.second; fails += 1; // } else { // std::cerr << result.second; } } catch (const colugo::SubprocessTimeOutException & e) { std::cerr << "(test '" << label << "' timed out)\n"; exit(1); } ++tree_idx; } return fails; }
static void path_cleanup( struct aa_rx_mp *mp, ompl::geometric::PathGeometric &path ) { amino::sgSpaceInformation::Ptr &si = mp->space_information; if( mp->simplify ) { ompl::geometric::PathSimplifier ps(si); int n = (int)path.getStateCount(); path.interpolate(n*10); for( int i = 0; i < 10; i ++ ) { ps.reduceVertices(path); ps.collapseCloseVertices(path); ps.shortcutPath(path); } ps.smoothBSpline(path, 3, path.length()/100.0); } }
int main(int argc, char* argv[]) { if (argc != 2) { std::cout << "Invalid input fromt the command line argument.\n"; return -1; } else { ProcessScheduler ps(argv[1]); if (!fileExists(ps.filename.c_str())) { std::cout << "File not found" << std::endl; return -1; } ps.readFile(); ps.run(); } return 0; }
int main(int argc, char **argv) { symbol_table_t st; // add symbols to st; PRE_IN_FIX(st, "+", 130, 110); PRE_IN_FIX(st, "-", 130, 110); INFIX(st, "*", 120); INFIX(st, "/", 120); INFIX(st, "%", 120); INFIX(st, "|", 70); INFIX(st, "^", 80); INFIX(st, "&", 90); INFIX(st, "<<", 100); INFIX(st, ">>", 100); PREFIX(st, "~", 130); INFIX_R(st, "**", 140); // SYMBOL(st, "(", 150); // usage { //char line[500]; if (argc != 2) return 1; char *line = argv[1]; //while (fgets(line, sizeof(line), stdin)) { parse_state_t ps(st); symbol_base_t *root = ps.parse(line, strlen(line)); printf ("%d\n", calc(root)); delete root; //} } return 0; }
/* * wr_string() writes a string to the operation screen at the location * specified by col and row. F_color is the color of the string * and B_color is the color of the background. blinking should be BLINK * if the string is to blink, and !BLINK if not. The last parameter is * a pointer to the null-terminated string. wr_string goes to the next * line if the current line is filled. * * wr_string() was modified to support writing to graphics screen * as well as text screen. If graphics has not been initialized, * writes messages to text screen. Necessary in order to see any * smx error messages that occur during initialization (these are * usually insufficient resource errors -- for example, failure to * create task due to lack of tcb's. */ void _cdecl wr_string(int col, int row, int F_color, int B_color, int blinking, const char *in_string) { #if (DEVICE_CONSOLE_OUT) #if (USES_UART) int was_unlocked; #endif if (!crt_is_init) return; #if (USES_UART) #if (USE_COLOR == 0) F_color = WHITE; B_color = BLACK; #endif was_unlocked = !IS_LOCKED(self); LOCK(self); ANSI_GotoXY(row,col); ANSI_SetGMode(F_color+30); ANSI_SetGMode(B_color+40); if (blinking) ANSI_SetGMode(BLINK); ps(in_string); ANSI_ClrEndOfLine(); if (was_unlocked) unlockx(self); #endif #if defined(PEG) && SMXPEG_CONSOLE_WINDOW //TODO: #endif #else /* Avoid compiler warning about unused pars. */ (void) col; (void) row; (void) F_color; (void) B_color; (void) blinking; (void) in_string; #endif }
void computeDB(const robot_model::RobotModelPtr &robot_model, unsigned int ns, unsigned int ne) { planning_scene::PlanningScenePtr ps(new planning_scene::PlanningScene(robot_model)); ompl_interface::OMPLInterface ompl_interface(robot_model); moveit_msgs::Constraints c = getConstraints(); ompl_interface::ConstraintApproximationConstructionOptions opt; opt.state_space_parameterization = "PoseModel"; opt.samples = ns; opt.edges_per_sample = ne; opt.explicit_motions = true; opt.max_edge_length = 0.2; opt.explicit_points_resolution = 0.05; opt.max_explicit_points = 10; ompl_interface.getConstraintsLibrary().addConstraintApproximation(c, "right_arm", ps, opt); ompl_interface.getConstraintsLibrary().saveConstraintApproximations("~/constraints_approximation_database"); ROS_INFO("Done"); }
PropertyRecordPtr XmlPropertyReader::getPropertiesAsRecord(DOMElement *parent) { PropertyRecordPtr ps(new PropertyRecord()); DOMNodeList* propertyDefChildren = parent->getChildNodes(); for (XMLSize_t childIdx = 0; childIdx < propertyDefChildren->getLength(); childIdx++) { DOMNode* curChild = propertyDefChildren->item(childIdx); if (curChild->getNodeType() == DOMNode::ELEMENT_NODE) { PropertyEntry entry = processProperty(static_cast<DOMElement*>(curChild)); if (entry.first != "") { ps->setProperty(entry.first, entry.second); } } } return ps; }
LDAPExpr::LDAPExpr( const std::string &filter ) : d() { ParseState ps(filter); try { LDAPExpr expr = ParseExpr(ps); if (!Trim(ps.rest()).empty()) { ps.error(GARBAGE + " '" + ps.rest() + "'"); } d = expr.d; } catch (const std::out_of_range&) { ps.error(EOS); } }
void main(int argc, char *argv[]) { int fd, i, tot, none = 1; Dir *dir, **mem; ARGBEGIN { case 'a': aflag++; break; case 'p': pflag++; break; case 'r': rflag++; break; } ARGEND; Binit(&bout, 1, OWRITE); if(chdir("/proc")==-1) error("/proc"); fd=open(".", OREAD); if(fd<0) error("/proc"); tot = dirreadall(fd, &dir); if(tot <= 0){ fprint(2, "ps: empty directory /proc\n"); exits("empty"); } mem = malloc(tot*sizeof(Dir*)); for(i=0; i<tot; i++) mem[i] = dir++; qsort(mem, tot, sizeof(Dir*), cmp); for(i=0; i<tot; i++){ ps(mem[i]->name); none = 0; } if(none) error("no processes; bad #p"); exits(0); }
void sMouseButton(GLFWwindow*, int32 button, int32 action, int32 mods) { double xd, yd; glfwGetCursorPos(mainWindow, &xd, &yd); b2Vec2 ps((float32)xd, (float32)yd); // Use the mouse to move things around. if (button == GLFW_MOUSE_BUTTON_1) { //<##> //ps.Set(0, 0); b2Vec2 pw = g_camera.ConvertScreenToWorld(ps); if (action == GLFW_PRESS) { if (mods == GLFW_MOD_SHIFT) { test->ShiftMouseDown(pw); } else { test->MouseDown(pw); } } if (action == GLFW_RELEASE) { test->MouseUp(pw); } } else if (button == GLFW_MOUSE_BUTTON_2) { if (action == GLFW_PRESS) { lastp = g_camera.ConvertScreenToWorld(ps); rightMouseDown = true; } if (action == GLFW_RELEASE) { rightMouseDown = false; } } }
void main( int argc, char ** argv ) { Environment env(argc, argv); WALBERLA_UNUSED(env); walberla::mpi::MPIManager::instance()->useWorldComm(); //init domain partitioning auto forest = blockforest::createBlockForest( AABB(0,0,0,20,20,20), // simulation domain Vector3<uint_t>(2,2,2), // blocks in each direction Vector3<bool>(false, false, false) // periodicity ); domain::BlockForestDomain domain(forest); //init data structures data::ParticleStorage ps(100); //initialize particle auto uid = createSphere(ps, domain); WALBERLA_LOG_DEVEL_ON_ROOT("uid: " << uid); //init kernels mpi::ReduceProperty RP; mpi::SyncNextNeighbors SNN; //sync SNN(ps, domain); auto pIt = ps.find(uid); if (pIt != ps.end()) { pIt->getForceRef() += Vec3(real_c(walberla::mpi::MPIManager::instance()->rank())); } RP.operator()<ForceTorqueNotification>(ps); if (walberla::mpi::MPIManager::instance()->rank() == 0) { WALBERLA_CHECK_FLOAT_EQUAL( pIt->getForce(), Vec3(real_t(28)) ); } else { WALBERLA_CHECK_FLOAT_EQUAL( pIt->getForce(), Vec3(real_t(walberla::mpi::MPIManager::instance()->rank())) ); } }
int main(int argc, char* argv[]) { if (argc != 4) { std::cerr << "usage: remote_thr <connect-to> <message-size> " << "<message-count>\n"; return 1; } std::string const ep = argv[1]; int message_size = std::atoi(argv[2]); int message_count = std::atoi(argv[3]); asio::io_service ios; asio::zmq::context ctx; asio::zmq::test::perf::pusher ps(ios, ctx, message_count, message_size, ep); ios.run(); }
bool move_group::MoveGroupPickPlaceAction::planUsingPickPlacePlace(const moveit_msgs::PlaceGoal& goal, moveit_msgs::PlaceResult* action_res, plan_execution::ExecutableMotionPlan& plan) { setPlaceState(PLANNING); planning_scene_monitor::LockedPlanningSceneRO ps(plan.planning_scene_monitor_); pick_place::PlacePlanPtr place_plan; try { place_plan = pick_place_->planPlace(plan.planning_scene_, goal); } catch (std::exception& ex) { ROS_ERROR_NAMED("manipulation", "Pick&place threw an exception: %s", ex.what()); } if (place_plan) { const std::vector<pick_place::ManipulationPlanPtr>& success = place_plan->getSuccessfulManipulationPlans(); if (success.empty()) { plan.error_code_ = place_plan->getErrorCode(); } else { const pick_place::ManipulationPlanPtr& result = success.back(); plan.plan_components_ = result->trajectories_; if (result->id_ < goal.place_locations.size()) action_res->place_location = goal.place_locations[result->id_]; plan.error_code_.val = moveit_msgs::MoveItErrorCodes::SUCCESS; action_res->planning_time = place_plan->getLastPlanTime(); } } else { plan.error_code_.val = moveit_msgs::MoveItErrorCodes::FAILURE; } return plan.error_code_.val == moveit_msgs::MoveItErrorCodes::SUCCESS; }
void pcl::gpu::PseudoConvexHull3D::reconstruct (const Cloud &cloud, DeviceArray2D<int>& vertexes) { const device::Cloud& c = (const device::Cloud&)cloud; device::FacetStream& fs = impl_->fs; device::PointStream ps(c); ps.computeInitalSimplex(); device::InitalSimplex simplex = ps.simplex; fs.setInitialFacets(ps.simplex); ps.initalClassify(); for(;;) { //new external points number ps.cloud_size = ps.searchFacetHeads(fs.facet_count, fs.head_points); if (ps.cloud_size == 0) break; fs.compactFacets(); ps.classify(fs); if (!fs.canSplit()) throw PCLException("Can't split facets, please enlarge default buffer", __FILE__, "", __LINE__); fs.splitFacets(); } int ecount; int fcount = fs.facet_count; fs.empty_count.download(&ecount); vertexes.create(3, fcount + ecount); DeviceArray2D<int> subf(3, fcount, vertexes.ptr(), vertexes.step()); DeviceArray2D<int> sube(3, ecount, vertexes.ptr()+fcount, vertexes.step()); DeviceArray2D<int>(3, fcount, fs.verts_inds.ptr(), fs.verts_inds.step()).copyTo(subf); DeviceArray2D<int>(3, ecount, fs.empty_facets.ptr(), fs.empty_facets.step()).copyTo(sube); }
main(int argc, char *argv[]) { char name[64]; int pid, cmd, segment, i; pid = getpid(); color = 0x000B + (pid % 5); // avoid black on black baground printf("enter main() : argc = %d\n", argc); for (i=0; i<argc; i++) printf("argv[%d] = %s\n", i, argv[i]); while(1){ pid = getpid(); color = 0x000B + (pid % 5); segment = (pid+1)*0x1000; printf("==============================================\n"); printf("I am proc %din U mode: segment=%x\n", pid, segment); show_menu(); printf("Command ? "); gets(name); if (name[0]==0) continue; cmd = find_cmd(name); switch(cmd){ case 0 : getpid(); break; case 1 : ps(); break; case 2 : chname(); break; case 3 : kmode(); break; case 4 : kswitch(); break; case 5 : wait(); break; case 6 : exit(); break; case 7 : fork(); break; case 8 : exec(); break; case 9: chcolor(); break; default: invalid(name); break; } } }