zarray.hpp

Go to the documentation of this file.

// This file is part of OpenCV project.
// It is subject to the license terms in the LICENSE file found in the top-level directory
// of this distribution and at http://opencv.org/license.html.
//
// Copyright (C) 2013-2016, The Regents of The University of Michigan.
//
// This software was developed in the APRIL Robotics Lab under the
// direction of Edwin Olson, ebolson@umich.edu. This software may be
// available under alternative licensing terms; contact the address above.
//
// The views and conclusions contained in the software and documentation are those
// of the authors and should not be interpreted as representing official policies,
// either expressed or implied, of the Regents of The University of Michigan.
#ifndef _OPENCV_ZARRAY_HPP_
#define _OPENCV_ZARRAY_HPP_

#include <stdlib.h>
#include <string.h>

namespace cv {
namespace aruco {


struct sQuad{
    float p[4][2]; // corners
};

typedef struct zarray zarray_t;
struct zarray{
    size_t el_sz; // size of each element

    int size; // how many elements?
    int alloc; // we've allocated storage for how many elements?
    char *data;
};

inline static zarray_t *_zarray_create(size_t el_sz){
    zarray_t *za = (zarray_t*) calloc(1, sizeof(zarray_t));
    za->el_sz = el_sz;
    return za;
}

inline static void _zarray_destroy(zarray_t *za){
    if (za == NULL)
        return;

    if (za->data != NULL)
        free(za->data);
    memset(za, 0, sizeof(zarray_t));
    free(za);
}

inline static int _zarray_size(const zarray_t *za){
    return za->size;
}

inline static void _zarray_ensure_capacity(zarray_t *za, int capacity){
    if (capacity <= za->alloc)
        return;

    while (za->alloc < capacity) {
        za->alloc *= 2;
        if (za->alloc < 8)
            za->alloc = 8;
    }

    za->data = (char*) realloc(za->data, za->alloc * za->el_sz);
}

inline static void _zarray_add(zarray_t *za, const void *p){
    _zarray_ensure_capacity(za, za->size + 1);

    memcpy(&za->data[za->size*za->el_sz], p, za->el_sz);
    za->size++;
}

inline static void _zarray_get(const zarray_t *za, int idx, void *p){
    CV_DbgAssert(idx >= 0);
    CV_DbgAssert(idx < za->size);

    memcpy(p, &za->data[idx*za->el_sz], za->el_sz);
}

inline static void _zarray_get_volatile(const zarray_t *za, int idx, void *p){
    CV_DbgAssert(idx >= 0);
    CV_DbgAssert(idx < za->size);

    *((void**) p) = &za->data[idx*za->el_sz];
}

inline static void _zarray_truncate(zarray_t *za, int sz){
    za->size = sz;
}

static inline void _zarray_set(zarray_t *za, int idx, const void *p, void *outp){
    CV_DbgAssert(idx >= 0);
    CV_DbgAssert(idx < za->size);

    if (outp != NULL)
        memcpy(outp, &za->data[idx*za->el_sz], za->el_sz);

    memcpy(&za->data[idx*za->el_sz], p, za->el_sz);
}

}
}
#endif