1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
// Copyright (C) 2013 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#include <boost/python.hpp>
#include <dlib/matrix.h>
#include <sstream>
#include <string>
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
#include <boost/python/suite/indexing/map_indexing_suite.hpp>
#include <boost/python/suite/indexing/indexing_suite.hpp>
#include <boost/shared_ptr.hpp>
#include <dlib/string.h>
#include "serialize_pickle.h"
#include "pyassert.h"
using namespace std;
using namespace dlib;
using namespace boost::python;
boost::shared_ptr<std::vector<double> > array_from_object(object obj)
{
extract<long> thesize(obj);
if (thesize.check())
{
long nr = thesize;
boost::shared_ptr<std::vector<double> > temp(new std::vector<double>(nr));
return temp;
}
else
{
const long nr = len(obj);
boost::shared_ptr<std::vector<double> > temp(new std::vector<double>(nr));
for ( long r = 0; r < nr; ++r)
{
(*temp)[r] = extract<double>(obj[r]);
}
return temp;
}
}
string array__str__ (const std::vector<double>& v)
{
std::ostringstream sout;
for (unsigned long i = 0; i < v.size(); ++i)
{
sout << v[i];
if (i+1 < v.size())
sout << "\n";
}
return sout.str();
}
string array__repr__ (const std::vector<double>& v)
{
std::ostringstream sout;
sout << "dlib.array([";
for (unsigned long i = 0; i < v.size(); ++i)
{
sout << v[i];
if (i+1 < v.size())
sout << ", ";
}
sout << "])";
return sout.str();
}
string range__str__ (const std::pair<unsigned long,unsigned long>& p)
{
std::ostringstream sout;
sout << p.first << ", " << p.second;
return sout.str();
}
string range__repr__ (const std::pair<unsigned long,unsigned long>& p)
{
std::ostringstream sout;
sout << "dlib.range(" << p.first << ", " << p.second << ")";
return sout.str();
}
struct range_iter
{
std::pair<unsigned long,unsigned long> range;
unsigned long cur;
unsigned long next()
{
if (cur < range.second)
{
return cur++;
}
else
{
PyErr_SetString(PyExc_StopIteration, "No more data.");
boost::python::throw_error_already_set();
return 0;
}
}
};
range_iter make_range_iterator (const std::pair<unsigned long,unsigned long>& p)
{
range_iter temp;
temp.range = p;
temp.cur = p.first;
return temp;
}
string pair__str__ (const std::pair<unsigned long,double>& p)
{
std::ostringstream sout;
sout << p.first << ": " << p.second;
return sout.str();
}
string pair__repr__ (const std::pair<unsigned long,double>& p)
{
std::ostringstream sout;
sout << "dlib.pair(" << p.first << ", " << p.second << ")";
return sout.str();
}
string sparse_vector__str__ (const std::vector<std::pair<unsigned long,double> >& v)
{
std::ostringstream sout;
for (unsigned long i = 0; i < v.size(); ++i)
{
sout << v[i].first << ": " << v[i].second;
if (i+1 < v.size())
sout << "\n";
}
return sout.str();
}
string sparse_vector__repr__ (const std::vector<std::pair<unsigned long,double> >& v)
{
std::ostringstream sout;
sout << "< dlib.sparse_vector containing: \n" << sparse_vector__str__(v) << " >";
return sout.str();
}
template <typename T>
void resize(T& v, unsigned long n) { v.resize(n); }
void bind_basic_types()
{
class_<std::vector<double> >("array", init<>())
.def(vector_indexing_suite<std::vector<double> >())
.def("__init__", make_constructor(&array_from_object))
.def("__str__", array__str__)
.def("__repr__", array__repr__)
.def("clear", &std::vector<double>::clear)
.def("resize", resize<std::vector<double> >)
.def_pickle(serialize_pickle<std::vector<double> >());
class_<std::vector<matrix<double,0,1> > >("vectors", "This object is an array of vector objects.")
.def(vector_indexing_suite<std::vector<matrix<double,0,1> > >())
.def("clear", &std::vector<matrix<double,0,1> >::clear)
.def("resize", resize<std::vector<matrix<double,0,1> > >)
.def_pickle(serialize_pickle<std::vector<matrix<double,0,1> > >());
{
typedef std::vector<std::vector<matrix<double,0,1> > > type;
class_<type>("vectorss", "This object is an array of arrays of vector objects.")
.def(vector_indexing_suite<type>())
.def("clear", &type::clear)
.def("resize", resize<type>)
.def_pickle(serialize_pickle<type>());
}
typedef pair<unsigned long,unsigned long> range_type;
class_<range_type>("range", "This object is used to represent a range of elements in an array.", init<>() )
.def(init<unsigned long,unsigned long>())
.def_readwrite("begin",&range_type::first, "The index of the first element in the range.")
.def_readwrite("end",&range_type::second, "One past the index of the last element in the range.")
.def("__str__", range__str__)
.def("__repr__", range__repr__)
.def("__iter__", &make_range_iterator)
.def_pickle(serialize_pickle<range_type>());
class_<range_iter>("_range_iter")
.def("next", &range_iter::next);
{
typedef std::vector<std::pair<unsigned long, unsigned long> > type;
class_<type>("ranges", "This object is an array of range objects.")
.def(vector_indexing_suite<type>())
.def("clear", &type::clear)
.def("resize", resize<type>)
.def_pickle(serialize_pickle<type>());
}
{
typedef std::vector<std::vector<std::pair<unsigned long, unsigned long> > > type;
class_<type>("rangess", "This object is an array of arrays of range objects.")
.def(vector_indexing_suite<type>())
.def("clear", &type::clear)
.def("resize", resize<type>)
.def_pickle(serialize_pickle<type>());
}
typedef pair<unsigned long,double> pair_type;
class_<pair_type>("pair", "This object is used to represent the elements of a sparse_vector.", init<>() )
.def(init<unsigned long,double>())
.def_readwrite("first",&pair_type::first, "This field represents the index/dimension number.")
.def_readwrite("second",&pair_type::second, "This field contains the value in a vector at dimension specified by the first field.")
.def("__str__", pair__str__)
.def("__repr__", pair__repr__)
.def_pickle(serialize_pickle<pair_type>());
class_<std::vector<pair_type> >("sparse_vector", "This object represents the mathematical idea of a column vector.")
.def(vector_indexing_suite<std::vector<pair_type> >())
.def("__str__", sparse_vector__str__)
.def("__repr__", sparse_vector__repr__)
.def("clear", &std::vector<pair_type >::clear)
.def("resize", resize<std::vector<pair_type > >)
.def_pickle(serialize_pickle<std::vector<pair_type> >());
class_<std::vector<std::vector<pair_type> > >("sparse_vectors", "This object is an array of sparse_vector objects.")
.def(vector_indexing_suite<std::vector<std::vector<pair_type> > >())
.def("clear", &std::vector<std::vector<pair_type> >::clear)
.def("resize", resize<std::vector<std::vector<pair_type> > >)
.def_pickle(serialize_pickle<std::vector<std::vector<pair_type> > >());
{
typedef std::vector<std::vector<std::vector<pair_type> > > type;
class_<type>("sparse_vectorss", "This object is an array of arrays of sparse_vector objects.")
.def(vector_indexing_suite<type>())
.def("clear", &type::clear)
.def("resize", resize<type>)
.def_pickle(serialize_pickle<type>());
}
}