void defineUtil() { // NOTE: This file has a ton of macros and templates, so it's going to take a while to compile ... init_numpy(); boost::python::numeric::array::set_module_and_type("numpy", "ndarray"); register_exception_translator<AssertException>(&translateAssertException); ADD_MODULE(util); // NOTE: When overloading functions always make sure to put the array/matrix function before the vector one MAT_CONV( MatrixX ); MAT_CONV( RMatrixX ); MAT_CONV( VectorX ); MAT_CONV( ArrayXX ); MAT_CONV( RArrayXX ); MAT_CONV( ArrayX ); // Define some std::vectors MAT_VEC( RMatrixX ); MAT_VEC( VectorX ); // Datastructures class_< std::vector<int> >("VecInt").def( vector_indexing_suite< std::vector<int> >() ).def( VectorInitSuite< std::vector<int> >() ); class_< std::vector<float> >("VecFloat").def( vector_indexing_suite< std::vector<float> >() ).def( VectorInitSuite< std::vector<float> >() ); }
void defineCRF() { ADD_MODULE(crf); class_<BinaryCRFFeatures, std::shared_ptr<BinaryCRFFeatures>, boost::noncopyable>("BinaryCRFFeatures",no_init) .add_property("unary", make_function( &BinaryCRFFeatures::unary, return_value_policy<return_by_value>() ) ) .add_property("pairwise", make_function( &BinaryCRFFeatures::pairwise, return_value_policy<return_by_value>() ) ) .add_property("graph", make_function( &BinaryCRFFeatures::graph, return_value_policy<return_by_value>() ) ); class_<StaticBinaryCRFFeatures, std::shared_ptr<StaticBinaryCRFFeatures>, bases<BinaryCRFFeatures> >("StaticBinaryCRFFeatures",init<ImageOverSegmentation>()); implicitly_convertible< std::shared_ptr<StaticBinaryCRFFeatures>, std::shared_ptr<BinaryCRFFeatures> >(); class_<BinaryCRF>( "BinaryCRF" ) .def( "inference", &BinaryCRF_inference ) .staticmethod( "inference" ) .def( "energy", &BinaryCRF::energy ) .staticmethod( "energy" ) .def( "inferenceWithLoss", &BinaryCRF::inferenceWithLoss ) .staticmethod( "inferenceWithLoss" ) .def( "train", BinaryCRF_train1 ) .def( "train", static_cast<void (BinaryCRF::*)( const std::shared_ptr<BinaryCRFFeatures>&, const VectorXs&)>( &BinaryCRF::train ) ) .def( "train", BinaryCRF_train2 ) .def( "train", static_cast<void (BinaryCRF::*)( const std::shared_ptr<BinaryCRFFeatures>&, const VectorXs&, const TrainingLoss &)>( &BinaryCRF::train ) ) .def( "train1Slack", &BinaryCRF::train1Slack ) .def( "trainNSlack", &BinaryCRF::trainNSlack ) .def( "diverseMBest", &BinaryCRF::diverseMBest ) .def( "map", &BinaryCRF_map ) .def( "e", &BinaryCRF::e ) .def_pickle(SaveLoad_pickle_suite<BinaryCRF>()); class_<TrainingLoss,std::shared_ptr<TrainingLoss>,boost::noncopyable>( "TrainingLoss", no_init ) .def("isLinear", &TrainingLoss::isLinear) .def("evaluate", static_cast<float (TrainingLoss::*)(float,float,float,float)const>(&TrainingLoss::evaluate) ) .def("evaluate", static_cast<float (TrainingLoss::*)(const VectorXf&, const VectorXf&)const>(&TrainingLoss::evaluate) ); class_<HammingLoss,std::shared_ptr<HammingLoss>, bases<TrainingLoss> >( "HammingLoss", init<float,float>() ) .def(init<>()); implicitly_convertible< std::shared_ptr<HammingLoss>, std::shared_ptr<TrainingLoss> >(); class_<AverageHammingLoss,std::shared_ptr<AverageHammingLoss>, bases<TrainingLoss> >( "AverageHammingLoss", init<float>() ) .def(init<>()); implicitly_convertible< std::shared_ptr<AverageHammingLoss>, std::shared_ptr<TrainingLoss> >(); class_<LinearJaccardLoss,std::shared_ptr<LinearJaccardLoss>, bases<TrainingLoss> >( "LinearJaccardLoss", init<float>() ) .def(init<>()); implicitly_convertible< std::shared_ptr<LinearJaccardLoss>, std::shared_ptr<TrainingLoss> >(); class_<ApproximateJaccardLoss,std::shared_ptr<ApproximateJaccardLoss>, bases<TrainingLoss> >( "ApproximateJaccardLoss", init<float,float>() ) .def(init<float>()) .def(init<>()); implicitly_convertible< std::shared_ptr<ApproximateJaccardLoss>, std::shared_ptr<TrainingLoss> >(); class_<JaccardLoss,std::shared_ptr<JaccardLoss>, bases<TrainingLoss> >( "JaccardLoss", init<float>() ) .def(init<>()); implicitly_convertible< std::shared_ptr<JaccardLoss>, std::shared_ptr<TrainingLoss> >(); }
void defineSegmentation() { ADD_MODULE(segmentation); // Helpers def("segmentBinaryGraph",segmentBinaryGraph); class_<IOUSet>("IOUSet", init<OverSegmentation>() ) .def( "maxIOU", &IOUSet::maxIOU ) .def( "intersects", static_cast<bool (IOUSet::*)(const VectorXb &, float) const>(&IOUSet::intersects) ) .def( "intersects", static_cast<bool (IOUSet::*)(const VectorXb &, const VectorXf &) const>(&IOUSet::intersects) ) .def( "add", &IOUSet::add ); /***** Over Segmentation *****/ class_<OverSegmentation,std::shared_ptr<OverSegmentation> >( "OverSegmentation", init<const Edges &, const VectorXf &>() ) .def(init<const Edges &>()) .add_property("Ns",&OverSegmentation::Ns) .add_property("edges",make_function(&OverSegmentation::edges,return_value_policy<return_by_value>())) .add_property("edge_weights",make_function(&OverSegmentation::edgeWeights,return_value_policy<return_by_value>()),&OverSegmentation::setEdgeWeights) .def_pickle( SaveLoad_pickle_suite_shared_ptr<OverSegmentation>() ); class_< ImageOverSegmentation,std::shared_ptr<ImageOverSegmentation>,bases<OverSegmentation> >( "ImageOverSegmentation", init<>() ) .def("boundaryMap",&ImageOverSegmentation::boundaryMap, ImageOverSegmentation_boundaryMap_overload()) .def("projectSegmentation",&ImageOverSegmentation::projectSegmentation, ImageOverSegmentation_projectSegmentation_overload()) .def("project",static_cast<VectorXf (ImageOverSegmentation::*)(const RMatrixXf&,const std::string &)const>( &ImageOverSegmentation::project )) .def("project",static_cast<RMatrixXf (ImageOverSegmentation::*)(const Image&,const std::string &)const>( &ImageOverSegmentation::project )) .def("projectBoundary",static_cast<VectorXf (ImageOverSegmentation::*)(const RMatrixXf&,const std::string &)const>( &ImageOverSegmentation::projectBoundary )) .def("projectBoundary",static_cast<VectorXf (ImageOverSegmentation::*)(const RMatrixXf&,const RMatrixXf&,const std::string &)const>( &ImageOverSegmentation::projectBoundary )) .def("maskToBox",&ImageOverSegmentation::maskToBox) .add_property("s",make_function(&ImageOverSegmentation::s,return_value_policy<return_by_value>())) .add_property("image",make_function(&ImageOverSegmentation::image,return_value_policy<return_by_value>())) .def_pickle( SaveLoad_pickle_suite_shared_ptr<ImageOverSegmentation>() ); implicitly_convertible< std::shared_ptr<ImageOverSegmentation>, std::shared_ptr<OverSegmentation> >(); class_< std::vector< std::shared_ptr<ImageOverSegmentation> > >("ImageOverSegmentationVec") .def( vector_indexing_suite< std::vector< std::shared_ptr<ImageOverSegmentation> >, true >() ) .def_pickle( VectorSaveLoad_pickle_suite_shared_ptr<ImageOverSegmentation>() ); def("geodesicKMeans",static_cast<std::shared_ptr<ImageOverSegmentation>(*)(const Image8u &, const BoundaryDetector &, int, int)>(geodesicKMeans)); def("geodesicKMeans",static_cast<std::shared_ptr<ImageOverSegmentation>(*)(const Image8u &, const BoundaryDetector &, int)>(geodesicKMeans)); def("geodesicKMeans",static_cast<std::shared_ptr<ImageOverSegmentation>(*)(const Image8u &, const SketchTokens &, int, int)>(geodesicKMeans)); def("geodesicKMeans",static_cast<std::shared_ptr<ImageOverSegmentation>(*)(const Image8u &, const SketchTokens &, int)>(geodesicKMeans)); def("geodesicKMeans",static_cast<std::shared_ptr<ImageOverSegmentation>(*)(const Image8u &, const StructuredForest &, int, int)>(geodesicKMeans)); def("geodesicKMeans",static_cast<std::shared_ptr<ImageOverSegmentation>(*)(const Image8u &, const StructuredForest &, int)>(geodesicKMeans)); def("geodesicKMeans",static_cast<std::shared_ptr<ImageOverSegmentation>(*)(const Image8u &, const DirectedSobel &, int, int)>(geodesicKMeans)); def("geodesicKMeans",static_cast<std::shared_ptr<ImageOverSegmentation>(*)(const Image8u &, const DirectedSobel &, int)>(geodesicKMeans)); def( "generateGeodesicKMeans", &generateGeodesicKMeans<BoundaryDetector> ); def( "generateGeodesicKMeans", &generateGeodesicKMeans<SketchTokens> ); def( "generateGeodesicKMeans", &generateGeodesicKMeans<StructuredForest> ); def( "generateGeodesicKMeans", &generateGeodesicKMeans<DirectedSobel> ); def( "boundaryDistance", &boundaryDistance ); }
void defineImgProc() { ADD_MODULE(imgproc); // Color def("rgb2luv",convert<0>); def("srgb2luv",convert<1>); def("rgb2lab",convert<2>); def("srgb2lab",convert<3>); def("rgb2hsv",convert<4>); // Filters def("boxFilter",boxFilter_m); def("tentFilter",tentFilter_m); def("gaussianFilter",gaussianFilter_m); def("exactGaussianFilter",exactGaussianFilter_m); def("percentileFilter",percentileFilter_m); // Gradient def("gradient",gradient2); def("gradientMag",gradientMag); def("gradientMagAndOri",gradientMagAndOri2); def("gradientHist",gradientHist2); // Morphology def("thin",thin); // NMS def("nms",nms); def("suppressBnd",suppressBnd2); // Upsampling def("upsample",upsample); def("upsampleLinear",upsampleLinear); def("downsample", (RMatrixXf(*)( const RMatrixXf &, int, int ))downsample); def("downsample", (Image(*)( const Image &, int, int ))downsample); def("padIm",padIm); // Other def("extractPatch",extractPatch); def("extractBoxes",extractBoxes); def("imread",imread); def("imwrite",imwrite); // Image and Image8u class_<Image,std::shared_ptr<Image> >("Image") .def(Image_indexing_suite<Image>()) .def("toImage8u",convertImage<Image,Image8u>); class_<Image8u,std::shared_ptr<Image8u> >("Image8u") .def(Image_indexing_suite<Image8u>()) .def("toImage",convertImage<Image,Image8u>); }
Session::Session(WebUserPtr& aUser, const string& aToken, bool aIsSecure, WebServerManager* aServer, uint64_t maxInactivityMinutes, bool aIsUserSession) : id(Util::rand()), user(aUser), token(aToken), started(GET_TICK()), lastActivity(GET_TICK()), secure(aIsSecure), server(aServer), maxInactivity(maxInactivityMinutes*1000*60), userSession(aIsUserSession) { ADD_MODULE("connectivity", ConnectivityApi); ADD_MODULE("events", EventApi); ADD_MODULE("favorite_directories", FavoriteDirectoryApi); ADD_MODULE("favorite_hubs", FavoriteHubApi); ADD_MODULE("filelists", FilelistApi); ADD_MODULE("filesystem", FilesystemApi); ADD_MODULE("hash", HashApi); ADD_MODULE("histories", HistoryApi); ADD_MODULE("hubs", HubApi); ADD_MODULE("private_chat", PrivateChatApi); ADD_MODULE("queue", QueueApi); ADD_MODULE("recent_hubs", RecentHubApi); ADD_MODULE("search", SearchApi); ADD_MODULE("settings", SettingApi); ADD_MODULE("share", ShareApi); ADD_MODULE("share_profiles", ShareProfileApi); ADD_MODULE("share_roots", ShareRootApi); ADD_MODULE("system", SystemApi); ADD_MODULE("transfers", TransferApi); ADD_MODULE("users", UserApi); ADD_MODULE("web_users", WebUserApi); ADD_MODULE("view_files", ViewFileApi); }
void defineUtil() { // NOTE: This file has a ton of macros and templates, so it's going to take a while to compile ... init_numpy(); boost::python::numeric::array::set_module_and_type("numpy", "ndarray"); register_exception_translator<AssertException>(&translateAssertException); ADD_MODULE(util); class_<Edge>("Edge") .def(init<int,int>()) .def_readonly( "a", &Edge::a ) .def_readonly( "b", &Edge::b ) .def_pickle(Edge_pickle()); class_< Edges >("Edges") .def(init<Edges>()) .def(vector_indexing_suite<Edges>()); def("qp",static_cast<VectorXf(*)(const RMatrixXf &, const VectorXf &, const RMatrixXf &, const VectorXf &)>(&qp)); def("qp",static_cast<VectorXd(*)(const RMatrixXd &, const VectorXd &, const RMatrixXd &, const VectorXd &)>(&qp)); // NOTE: When overloading functions always make sure to put the array/matrix function before the vector one MAT_CONV( MatrixX ); MAT_CONV( RMatrixX ); MAT_CONV( VectorX ); MAT_CONV( ArrayXX ); MAT_CONV( RArrayXX ); MAT_CONV( ArrayX ); // Defien some std::vectors MAT_VEC( RMatrixX ); MAT_VEC( VectorX ); class_< std::vector< std::vector<RMatrixXb> > >("VecVecRMatrixXb") .def( vector_indexing_suite< std::vector< std::vector<RMatrixXb> >, true >() ) .def( VectorInitSuite< std::vector< std::vector<RMatrixXb> > >() ); // Datastructures class_< std::vector<int> >("VecInt").def( vector_indexing_suite< std::vector<int> >() ).def( VectorInitSuite< std::vector<int> >() ); class_< std::vector<float> >("VecFloat").def( vector_indexing_suite< std::vector<float> >() ).def( VectorInitSuite< std::vector<float> >() ); class_< std::vector<std::string> >("VecStr").def( vector_indexing_suite< std::vector<std::string> >() ).def( VectorInitSuite< std::vector<std::string> >() ); // class_<Polygons>("Polygons").def( vector_indexing_suite<Polygons,true >() ); class_< std::vector<Polygons> >("VecPolygons").def( vector_indexing_suite< std::vector<Polygons> >() ) .def_pickle(VecPolygons_pickle_suite()); // Rasterize def("rasterize",static_cast<RMatrixXf(*)(const Polygon &,int)>(&rasterize),rasterize1()); def("rasterize",static_cast<RMatrixXf(*)(const Polygons &,int)>(&rasterize),rasterize2()); // Facility location class_<Floc>("Floc") .def("energy",Floc::energy) .staticmethod("energy") .def("greedy",Floc::greedy) .staticmethod("greedy") .def("jms",Floc::jms) .staticmethod("jms") .def("myz",Floc::myz) .staticmethod("myz") .def("local",Floc::local) .staticmethod("local") .def("scaledLocal",Floc::scaledLocal) .staticmethod("scaledLocal") .def("tabu",Floc::tabu) .staticmethod("tabu"); // Geodesic distance class_<GeodesicDistance>("GeodesicDistance",init<Edges,VectorXf>()) .def("compute",static_cast<VectorXf (GeodesicDistance::*)(int)const>( &GeodesicDistance::compute )) .def("compute",static_cast<VectorXf (GeodesicDistance::*)(const VectorXf &)const>( &GeodesicDistance::compute )) .add_property("N",&GeodesicDistance::N); }