Packages
evision
0.1.18
1.0.1-rc.0
1.0.0
1.0.0-rc.0
0.2.17
0.2.17-rc2
0.2.17-rc1
0.2.16
0.2.16-pre.2
0.2.16-pre
0.2.15
0.2.14
0.2.13
0.2.12
0.2.11
0.2.9
0.2.8
0.2.7
0.2.6
0.2.5
0.2.4
0.2.3
0.2.2
0.2.2-rc2
0.2.1
0.2.0
0.1.39
0.1.38
0.1.37
0.1.36
0.1.35
0.1.34
0.1.33
0.1.32
retired
0.1.31
0.1.30
0.1.29
0.1.28
0.1.27
0.1.26
0.1.26-rc3
0.1.26-rc2
0.1.26-rc1
0.1.26-rc0
0.1.25
0.1.24
0.1.23
0.1.22
0.1.21
0.1.20
0.1.19
0.1.18
0.1.17
0.1.16
0.1.15
0.1.14
0.1.13
0.1.12
0.1.11
0.1.10
0.1.9
0.1.8
0.1.7
OpenCV-Erlang/Elixir binding.
Current section
Files
Jump to
Current section
Files
c_src/evision_custom_headers/evision_dnn.hpp
#ifdef HAVE_OPENCV_DNN
typedef dnn::DictValue LayerId;
typedef std::vector<dnn::MatShape> vector_MatShape;
typedef std::vector<std::vector<dnn::MatShape> > vector_vector_MatShape;
//template<>
//bool evision_to(ErlNifEnv *env, ERL_NIF_TERM obj, dnn::Net &net, const ArgInfo& info)
//{
// if (evision::nif::check_nil(env, obj)) {
// return false;
// }
//
// evision_res<cv::dnn::Net> * in_res;
// if( enif_get_resource(env, obj, evision_res<cv::dnn::Net>::type, (void **)&in_res) ) {
// net = in_res->val;
// return true;
// }
// return false;
//}
template<>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::DetectionModel& model)
{
evision_res<dnn::DetectionModel> * res;
if (alloc_resource(&res)) {
res->val = model;
} else {
return evision::nif::error(env, "no memory");
}
ERL_NIF_TERM ret = enif_make_resource(env, res);
enif_release_resource(res);
return ret;
}
template<>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::Model& model)
{
evision_res<dnn::Model> * res;
if (alloc_resource(&res)) {
res->val = model;
} else {
return evision::nif::error(env, "no memory");
}
ERL_NIF_TERM ret = enif_make_resource(env, res);
enif_release_resource(res);
return ret;
}
//template<>
//ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::Net& model)
//{
// printf("evision_from did read\r\n");
// fflush(stdout);
// evision_res<dnn::Model> * res;
// if (alloc_resource(&res)) {
// res->val = model;
// printf("net: %p\r\n", &res->val);
// } else {
// return evision::nif::error(env, "no memory");
// }
//
// ERL_NIF_TERM ret = enif_make_resource(env, res);
// enif_release_resource(res);
// return ret;
//}
template<>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::TextDetectionModel_DB& model)
{
evision_res<dnn::TextDetectionModel_DB> * res;
if (alloc_resource(&res)) {
res->val = model;
} else {
return evision::nif::error(env, "no memory");
}
ERL_NIF_TERM ret = enif_make_resource(env, res);
enif_release_resource(res);
return ret;
}
template<>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::TextDetectionModel_EAST& model)
{
evision_res<dnn::TextDetectionModel_EAST> * res;
if (alloc_resource(&res)) {
res->val = model;
} else {
return evision::nif::error(env, "no memory");
}
ERL_NIF_TERM ret = enif_make_resource(env, res);
enif_release_resource(res);
return ret;
}
template<>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::TextRecognitionModel& model)
{
evision_res<dnn::TextRecognitionModel> * res;
if (alloc_resource(&res)) {
res->val = model;
} else {
return evision::nif::error(env, "no memory");
}
ERL_NIF_TERM ret = enif_make_resource(env, res);
enif_release_resource(res);
return ret;
}
template<>
bool evision_to(ErlNifEnv *env, ERL_NIF_TERM obj, dnn::DictValue &dv, const ArgInfo& info)
{
if (evision::nif::check_nil(env, obj)) {
return true; //Current state will be used
}
ErlNifSInt64 int64_val;
int int_val;
double f64_val;
if (enif_get_int64(env, obj, &int64_val))
{
dv = dnn::DictValue((int64)int64_val);
return true;
}
else if (enif_get_int(env, obj, &int_val))
{
dv = dnn::DictValue((int64)int_val);
return true;
}
else if (enif_get_double(env, obj, &f64_val))
{
dv = dnn::DictValue(f64_val);
return true;
}
else
{
std::string str;
if (evision::nif::get(env, obj, str))
{
dv = dnn::DictValue(str);
return true;
}
}
return false;
}
template<typename T>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::DictValue &dv)
{
if (dv.size() > 1)
{
std::vector<T> vec(dv.size());
for (int i = 0; i < dv.size(); ++i)
vec[i] = dv.get<T>(i);
return evision_from_generic_vec(env, vec);
}
else
return evision_from(env, dv.get<T>());
}
template<>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::DictValue &dv)
{
if (dv.isInt()) return evision_from<int>(env, dv);
if (dv.isReal()) return evision_from<float>(env, dv);
if (dv.isString()) return evision_from<String>(env, dv);
CV_Error(Error::StsNotImplemented, "Unknown value type");
return evision::nif::atom(env, "nil");
}
template<>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const dnn::LayerParams& lp)
{
std::vector<ERL_NIF_TERM> _keys, _values;
size_t i = 0;
for (std::map<String, dnn::DictValue>::const_iterator it = lp.begin(); it != lp.end(); ++it)
{
_keys.push_back(evision::nif::make(env, it->first.c_str()));
_values.push_back(evision_from(env, it->second));
i++;
}
ERL_NIF_TERM dict;
size_t s = _keys.size();
ERL_NIF_TERM * keys = (ERL_NIF_TERM *)enif_alloc(sizeof(ERL_NIF_TERM) * s);
ERL_NIF_TERM * values = (ERL_NIF_TERM *)enif_alloc(sizeof(ERL_NIF_TERM) * s);
for (size_t i = 0; i < s; i++) {
keys[i] = _keys[i];
values[i] = _values[i];
}
if (enif_make_map_from_arrays(env, keys, values, i, &dict)) {
enif_free((void *)keys);
enif_free((void *)values);
return dict;
} else {
enif_free((void *)keys);
enif_free((void *)values);
return evision::nif::atom(env, "nil");
}
}
template<>
ERL_NIF_TERM evision_from(ErlNifEnv *env, const std::vector<dnn::Target> &t)
{
return evision_from(env, std::vector<int>(t.begin(), t.end()));
}
#endif // HAVE_OPENCV_DNN