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);
}
