virtual nsapi_error_t socket_connect(nsapi_socket_t socket, const SocketAddress &address)
{
if (!_stack_api()->socket_connect) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->socket_connect(_stack(), socket, address.get_addr(), address.get_port());
}
virtual int socket_bind(nsapi_socket_t socket, const SocketAddress &address)
{
if (!_stack_api()->socket_bind) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->socket_bind(_stack(), socket, address.get_addr(), address.get_port());
}
virtual void socket_attach(nsapi_socket_t socket, void (*callback)(void *), void *data)
{
if (!_stack_api()->socket_attach) {
return;
}
return _stack_api()->socket_attach(_stack(), socket, callback, data);
}
virtual nsapi_size_or_error_t socket_sendto(nsapi_socket_t socket, const SocketAddress &address, const void *data, nsapi_size_t size)
{
if (!_stack_api()->socket_sendto) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->socket_sendto(_stack(), socket, address.get_addr(), address.get_port(), data, size);
}
virtual int getstackopt(int level, int optname, void *optval, unsigned *optlen)
{
if (!_stack_api()->getstackopt) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->getstackopt(_stack(), level, optname, optval, optlen);
}
virtual nsapi_size_or_error_t socket_recv(nsapi_socket_t socket, void *data, nsapi_size_t size)
{
if (!_stack_api()->socket_recv) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->socket_recv(_stack(), socket, data, size);
}
virtual nsapi_error_t socket_listen(nsapi_socket_t socket, int backlog)
{
if (!_stack_api()->socket_listen) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->socket_listen(_stack(), socket, backlog);
}
virtual int socket_recv(nsapi_socket_t socket, void *data, unsigned size)
{
if (!_stack_api()->socket_recv) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->socket_recv(_stack(), socket, data, size);
}
virtual nsapi_error_t socket_open(nsapi_socket_t *socket, nsapi_protocol_t proto)
{
if (!_stack_api()->socket_open) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->socket_open(_stack(), socket, proto);
}
virtual nsapi_error_t socket_close(nsapi_socket_t socket)
{
if (!_stack_api()->socket_close) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->socket_close(_stack(), socket);
}
virtual nsapi_error_t setstackopt(int level, int optname, const void *optval, unsigned optlen)
{
if (!_stack_api()->setstackopt) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->setstackopt(_stack(), level, optname, optval, optlen);
}
virtual nsapi_error_t add_dns_server(const SocketAddress &address)
{
if (!_stack_api()->add_dns_server) {
return NetworkStack::add_dns_server(address);
}
return _stack_api()->add_dns_server(_stack(), address.get_addr());
}
virtual nsapi_error_t getsockopt(nsapi_socket_t socket, int level, int optname, void *optval, unsigned *optlen)
{
if (!_stack_api()->getsockopt) {
return NSAPI_ERROR_UNSUPPORTED;
}
return _stack_api()->getsockopt(_stack(), socket, level, optname, optval, optlen);
}
virtual nsapi_error_t gethostbyname(const char *name, SocketAddress *address, nsapi_version_t version)
{
if (!_stack_api()->gethostbyname) {
return NetworkStack::gethostbyname(name, address, version);
}
nsapi_addr_t addr = {NSAPI_UNSPEC, 0};
nsapi_error_t err = _stack_api()->gethostbyname(_stack(), name, &addr, version);
address->set_addr(addr);
return err;
}
virtual int gethostbyname(SocketAddress *address, const char *name)
{
if (!_stack_api()->gethostbyname) {
return NetworkStack::gethostbyname(address, name);
}
nsapi_addr_t addr = {NSAPI_IPv4, 0};
int err = _stack_api()->gethostbyname(_stack(), &addr, name);
address->set_addr(addr);
return err;
}
virtual nsapi_size_or_error_t socket_recvfrom(nsapi_socket_t socket, SocketAddress *address, void *data, nsapi_size_t size)
{
if (!_stack_api()->socket_recvfrom) {
return NSAPI_ERROR_UNSUPPORTED;
}
nsapi_addr_t addr = {NSAPI_IPv4, 0};
uint16_t port = 0;
nsapi_size_or_error_t err = _stack_api()->socket_recvfrom(_stack(), socket, &addr, &port, data, size);
if (address) {
address->set_addr(addr);
address->set_port(port);
}
return err;
}
virtual nsapi_error_t socket_accept(nsapi_socket_t server, nsapi_socket_t *socket, SocketAddress *address)
{
if (!_stack_api()->socket_accept) {
return NSAPI_ERROR_UNSUPPORTED;
}
nsapi_addr_t addr = {NSAPI_IPv4, 0};
uint16_t port = 0;
nsapi_error_t err = _stack_api()->socket_accept(_stack(), server, socket, &addr, &port);
if (address) {
address->set_addr(addr);
address->set_port(port);
}
return err;
}
virtual const char *get_ip_address()
{
if (!_stack_api()->get_ip_address) {
return 0;
}
static uint8_t buffer[sizeof(SocketAddress)];
SocketAddress *address = new (buffer) SocketAddress(_stack_api()->get_ip_address(_stack()));
return address->get_ip_address();
}
void convexHull( InputArray _points, OutputArray _hull, bool clockwise, bool returnPoints )
{
CV_INSTRUMENT_REGION()
CV_Assert(_points.getObj() != _hull.getObj());
Mat points = _points.getMat();
int i, total = points.checkVector(2), depth = points.depth(), nout = 0;
int miny_ind = 0, maxy_ind = 0;
CV_Assert(total >= 0 && (depth == CV_32F || depth == CV_32S));
if( total == 0 )
{
_hull.release();
return;
}
returnPoints = !_hull.fixedType() ? returnPoints : _hull.type() != CV_32S;
bool is_float = depth == CV_32F;
AutoBuffer<Point*> _pointer(total);
AutoBuffer<int> _stack(total + 2), _hullbuf(total);
Point** pointer = _pointer;
Point2f** pointerf = (Point2f**)pointer;
Point* data0 = points.ptr<Point>();
int* stack = _stack;
int* hullbuf = _hullbuf;
CV_Assert(points.isContinuous());
for( i = 0; i < total; i++ )
pointer[i] = &data0[i];
// sort the point set by x-coordinate, find min and max y
if( !is_float )
{
std::sort(pointer, pointer + total, CHullCmpPoints<int>());
for( i = 1; i < total; i++ )
{
int y = pointer[i]->y;
if( pointer[miny_ind]->y > y )
miny_ind = i;
if( pointer[maxy_ind]->y < y )
maxy_ind = i;
}
}
else
{
std::sort(pointerf, pointerf + total, CHullCmpPoints<float>());
for( i = 1; i < total; i++ )
{
float y = pointerf[i]->y;
if( pointerf[miny_ind]->y > y )
miny_ind = i;
if( pointerf[maxy_ind]->y < y )
maxy_ind = i;
}
}
if( pointer[0]->x == pointer[total-1]->x &&
pointer[0]->y == pointer[total-1]->y )
{
hullbuf[nout++] = 0;
}
else
{
// upper half
int *tl_stack = stack;
int tl_count = !is_float ?
Sklansky_( pointer, 0, maxy_ind, tl_stack, -1, 1) :
Sklansky_( pointerf, 0, maxy_ind, tl_stack, -1, 1);
int *tr_stack = stack + tl_count;
int tr_count = !is_float ?
Sklansky_( pointer, total-1, maxy_ind, tr_stack, -1, -1) :
Sklansky_( pointerf, total-1, maxy_ind, tr_stack, -1, -1);
// gather upper part of convex hull to output
if( !clockwise )
{
std::swap( tl_stack, tr_stack );
std::swap( tl_count, tr_count );
}
for( i = 0; i < tl_count-1; i++ )
hullbuf[nout++] = int(pointer[tl_stack[i]] - data0);
for( i = tr_count - 1; i > 0; i-- )
hullbuf[nout++] = int(pointer[tr_stack[i]] - data0);
int stop_idx = tr_count > 2 ? tr_stack[1] : tl_count > 2 ? tl_stack[tl_count - 2] : -1;
// lower half
int *bl_stack = stack;
int bl_count = !is_float ?
Sklansky_( pointer, 0, miny_ind, bl_stack, 1, -1) :
Sklansky_( pointerf, 0, miny_ind, bl_stack, 1, -1);
int *br_stack = stack + bl_count;
int br_count = !is_float ?
Sklansky_( pointer, total-1, miny_ind, br_stack, 1, 1) :
Sklansky_( pointerf, total-1, miny_ind, br_stack, 1, 1);
if( clockwise )
{
std::swap( bl_stack, br_stack );
std::swap( bl_count, br_count );
}
if( stop_idx >= 0 )
{
int check_idx = bl_count > 2 ? bl_stack[1] :
bl_count + br_count > 2 ? br_stack[2-bl_count] : -1;
if( check_idx == stop_idx || (check_idx >= 0 &&
pointer[check_idx]->x == pointer[stop_idx]->x &&
pointer[check_idx]->y == pointer[stop_idx]->y) )
{
// if all the points lie on the same line, then
// the bottom part of the convex hull is the mirrored top part
// (except the exteme points).
bl_count = MIN( bl_count, 2 );
br_count = MIN( br_count, 2 );
}
}
for( i = 0; i < bl_count-1; i++ )
hullbuf[nout++] = int(pointer[bl_stack[i]] - data0);
for( i = br_count-1; i > 0; i-- )
hullbuf[nout++] = int(pointer[br_stack[i]] - data0);
}
if( !returnPoints )
Mat(nout, 1, CV_32S, hullbuf).copyTo(_hull);
else
{
_hull.create(nout, 1, CV_MAKETYPE(depth, 2));
Mat hull = _hull.getMat();
size_t step = !hull.isContinuous() ? hull.step[0] : sizeof(Point);
for( i = 0; i < nout; i++ )
*(Point*)(hull.ptr() + i*step) = data0[hullbuf[i]];
}
}
inline const nsapi_stack_api_t *_stack_api()
{
return _stack()->stack_api;
}
