src/vsvector.c

   1 /*
   2  * dcvector.c -- a dynamic array
   3  * (C) 2011 - Georg Martius
   4  *   georg dot martius at web dot de
   5  *
   6  *  This file is part of vid.stab video stabilization library
   7  *
   8  *  vid.stab is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License,
  10  *  as published by the Free Software Foundation; either version 2, or
  11  *  (at your option) any later version.
  12  *
  13  *  vid.stab is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with GNU Make; see the file COPYING.  If not, write to
  20  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #include "vsvector.h"
  24 #include "vidstabdefines.h"
  25 #include <assert.h>
  26 #include <string.h>
  27
  28
  29 /*************************************************************************/
  30 int vs_vector_resize(VSVector *V, int newsize);
  31
  32 /*************************************************************************/
  33
  34 int vs_vector_init(VSVector *V, int buffersize){
  35   assert(V);
  36   if(buffersize>0){
  37     V->data=(void**)vs_zalloc(sizeof(void*)*buffersize);
  38     if(!V->data) return VS_ERROR;
  39   }else{
  40     V->data = 0;
  41     buffersize = 0;
  42   }
  43   V->buffersize=buffersize;
  44   V->nelems=0;
  45   return VS_OK;
  46 }
  47
  48 int vs_vector_fini(VSVector *V){
  49   assert(V);
  50   if(V->data) vs_free(V->data);
  51   V->data = 0;
  52   V->buffersize=0;
  53   V->nelems=0;
  54   return VS_OK;
  55 }
  56
  57 int vs_vector_del(VSVector *V){
  58   vs_vector_zero(V);
  59   return vs_vector_fini(V);
  60 }
  61
  62 int vs_vector_zero(VSVector *V){
  63   assert(V);
  64   assert(V->nelems < 1 || V->data);
  65   int i;
  66   for(i=0; i < V->nelems; i++){
  67     if(V->data[i])
  68       vs_free(V->data[i]);
  69   }
  70   V->nelems=0;
  71   return VS_OK;
  72
  73 }
  74
  75 int vs_vector_size(const VSVector *V){
  76   assert(V);
  77   return V->nelems;
  78 }
  79
  80
  81 int vs_vector_append(VSVector *V, void *data){
  82   assert(V && data);
  83   if(!V->data || V->buffersize < 1) vs_vector_init(V,4);
  84   if(V->nelems >= V->buffersize){
  85     if(vs_vector_resize(V, V->buffersize*2)!=VS_OK) return VS_ERROR;
  86   }
  87   V->data[V->nelems]=data;
  88   V->nelems++;
  89   return VS_OK;
  90 }
  91
  92 int vs_vector_append_dup(VSVector *V, void *data, int data_size){
  93   assert(V && data);
  94   if(!V->data || V->buffersize < 1) vs_vector_init(V,4);
  95   void* d = vs_malloc(data_size);
  96   if(!d) return VS_ERROR;
  97   memcpy(d, data, data_size);
  98   return vs_vector_append(V, d);
  99 }
 100
 101
 102 void *vs_vector_get(const VSVector *V, int pos){
 103   assert(V && V->data);
 104   if(pos<0 || pos >= V->nelems)
 105     return 0;
 106   else
 107     return V->data[pos];
 108 }
 109
 110 void* vs_vector_set(VSVector *V, int pos, void *data){
 111   assert(V && data && pos>=0);
 112   if(!V->data || V->buffersize < 1) vs_vector_init(V,4);
 113   if(V->buffersize <= pos) {
 114     int nsize = V->buffersize;
 115     while(nsize <= pos) nsize *=2;
 116     if(vs_vector_resize(V, nsize)!=VS_OK) return 0; // insuficient error handling here! VS_ERROR
 117   }
 118   if(pos >= V->nelems){ // insert after end of vector
 119     int i;
 120     for(i=V->nelems; i< pos+1; i++){
 121       V->data[i]=0;
 122     }
 123     V->nelems=pos+1;
 124   }
 125   void* old = V->data[pos];
 126   V->data[pos] = data;
 127   return old;
 128 }
 129
 130 void* vs_vector_set_dup(VSVector *V, int pos, void *data, int data_size){
 131   void* d = vs_malloc(data_size);
 132   if(!d) return 0; // insuficient error handling here! VS_ERROR
 133   memcpy(d, data, data_size);
 134   return vs_vector_set(V, pos, d);
 135 }
 136
 137
 138 int vs_vector_resize(VSVector *V, int newsize){
 139   assert(V && V->data);
 140   if(newsize<1) newsize=1;
 141   V->data = (void**)vs_realloc(V->data, newsize * sizeof(void*));
 142   V->buffersize=newsize;
 143   if(V->nelems>V->buffersize){
 144     V->nelems=V->buffersize;
 145   }
 146   if (!V->data){
 147     vs_log_error("VS_Vector","out of memory!");
 148     return VS_ERROR;
 149   } else
 150     return VS_OK;
 151 }
 152
 153 VSVector vs_vector_filter(const VSVector *V, short (*pred)(void*, void*), void* param){
 154   VSVector result;
 155   assert(V);
 156   vs_vector_init(&result, V->nelems);
 157   for(int i=0; i< V->nelems; i++){
 158     if(pred(param, V->data[i]))
 159       vs_vector_append(&result, V->data[i]);
 160   }
 161   return result;
 162 }
 163
 164 VSVector vs_vector_concat(const VSVector *V1, const VSVector *V2){
 165   VSVector result;
 166   assert(V1 && V2);
 167   vs_vector_init(&result, V1->nelems + V2->nelems);
 168   memcpy(result.data, V1->data, sizeof(void*)* V1->nelems);
 169   memcpy(result.data+V1->nelems, V2->data, sizeof(void*)* V2->nelems);
 170   result.nelems=V1->nelems+V2->nelems;
 171   return result;
 172 }
 173
 174
 175 /* ARRAY */
 176
 177 VSArray vs_array_new(int len){
 178   VSArray a;
 179   a.dat = (double*)vs_zalloc(sizeof(double)*len);
 180   a.len = len;
 181   return a;
 182 }
 183
 184 VSArray vs_array(double vals[],int len){
 185   VSArray a = vs_array_new(len);
 186   memcpy(a.dat,vals, sizeof(double)*len);
 187   return a;
 188 }
 189
 190 VSArray* vs_array_plus(VSArray* c, VSArray a, VSArray b){
 191   int i;
 192   assert(a.len == b.len);
 193   if(c->len == 0 ) *c = vs_array_new(a.len);
 194   for(i=0; i< a.len; i++) c->dat[i]=a.dat[i]+b.dat[i];
 195   return c;
 196 }
 197
 198 VSArray* vs_array_scale(VSArray* c, VSArray a, double f){
 199   if(c->len == 0 ) *c = vs_array_new(a.len);
 200   for(int i=0; i< a.len; i++) c->dat[i]=a.dat[i]*f;
 201   return c;
 202 }
 203
 204 VSArray vs_array_copy(VSArray a){
 205   VSArray c = vs_array_new(a.len);
 206   memcpy(c.dat, a.dat, a.len*sizeof(double));
 207   return c;
 208 }
 209
 210 void vs_array_zero(VSArray* a){
 211   memset(a->dat,0,sizeof(double)*a->len);
 212 }
 213
 214 void vs_array_swap(VSArray* a, VSArray* b){
 215   VSArray tmp;
 216   tmp = *a;
 217   *a = *b;
 218   *b = tmp;
 219 }
 220
 221 void vs_array_free(VSArray a){
 222   vs_free(a.dat);
 223   a.dat=0;
 224   a.len=0;
 225 }
 226
 227 void vs_array_print(VSArray a, FILE* f){
 228   for(int i=0; i<a.len; i++){
 229     fprintf(f, "%g ", a.dat[i]);
 230   }
 231 }
 232
 233
 234 /*
 235  * Local variables:
 236  *   c-file-style: "stroustrup"
 237  *   c-file-offsets: ((case-label . *) (statement-case-intro . *))
 238  *   indent-tabs-mode: nil
 239  *   c-basic-offset: 2 t
 240  * End:
 241  *
 242  * vim: expandtab shiftwidth=4:
 243  */
 244