AllocMem.h

/*******************************************************************************
*                           OPEN SOURCE CODE DISCLAIMER                        *
* FILE NAME:          AllocMem.h                                               *
* DATE:               25/2/2003 (from mytypes.h)                                *
* PURPOSE:            Header for image handling types                          *
* ORIGINAL CODE BY:   Juan Andrade Cetto                                       *
*                     Joan Purcalla Arrufí                                     *
*                     (C) Institut de Robòtica Industrial                      *
*                     Universidad Politècnica de Catalunya                     *
* ALGORITHM BASED ON: Simple data structures                                   *
* CONTRIBUTOR(S):     (name, date, and brief description of contribution)      *
*                                                                              *
* The contents of this file are subject to the Mozilla Public License; you may *
* not use this file except in compliance with the License. You may obtain a    *
* copy of the License at http://www.mozilla.org/MPL/                           *
* Software distributed under the License is distributed on an "AS IS" basis,   *
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for *
* the specific language governing rights and limitations under the License.    *
*                                                                              *
* You may modify this code (or portions thereof) provided a copy of this       *
* disclaimer is included in the modified version.                              *
*******************************************************************************/

#ifndef ALLOC_MEM_H
#define ALLOC_MEM_H

typedef struct pixel_struct {
    double  r,g,b;  
} pixel_type;

typedef struct node_struct {
    pixel_type  color;          // pixel color
    int         rank;           // rank (depth of tree) pp. 448 Cormen,Leiserson,Rivest
                                // Upper bound of the heigth of the node
    int         parent;         // parent
    int         area;           // area of segment (down the tree)
    float       maxw;           // maxw within segment
} node_type;

typedef struct edge_struct {
    float   w;      // distance in color between pixels
    short   r,c;  // pixel 1
    unsigned char   dir;
} edge_type;

typedef struct blob_struct {
  double area,
         cogx,
         cogy;
  long   label;
  int    minx,maxx,miny,maxy;  // minx, maxx, miny, maxy
  int    perim;
} blob_type;

//Allocate an array of NStrings vectors of Type_Size type size,
//each vector length is specified in the array "strings"
// i.e. strings[i] contains the length of the i-th vector 
 void** alloc_vec_vec(size_t NStrings, size_t *strings, size_t TypeSize);

//Release the memory allocated with alloc_vec_vec
 void free_vec_vec(void *pPointer);


 //****************************************************
 //* CHAR pointer allocation routines
 //****************************************************
 char* alloc_vec_char(int); //char vector
 char** alloc_mat_char(int, int); //char matrix
 char ***allocCubeChar ( unsigned uDepth, unsigned uHeight, unsigned uWidth ); //char cube
 //*****************************************************
 //* CHAR free routines
 //********************************************************
 void release_vec_char(char*); //char vector
 void release_mat_char(char**); //char matrix
 void releaseCubeChar (char ***); //char cube
 
 //**********************************************************
 //* UNSIGNED CHAR pointer allocation routines
 //**********************************************************
 unsigned char* alloc_vec_uchar(int);
 unsigned char** alloc_mat_uchar(int, int);
 unsigned char ***allocCubeUchar ( unsigned uDepth, unsigned uHeight, unsigned uWidth );
 //**********************************************************
 //* UNSIGNED CHAR free routines
 //**********************************************************
 void release_vec_uchar(unsigned char*);
 void release_mat_uchar(unsigned char**);
 void releaseCubeUchar (unsigned char***);

 int **alloc_mat(int , int);
 int * alloc_vec_int(int );
 void release_vec_int(int* v);
 void release_mat_int(int** M);
 long* alloc_vec_long(int);
 long** alloc_mat_long(int, int);
 void release_vec_long(long*);
 void release_mat_long(long**);
 float* alloc_vec_float(int);
 void release_vec_float(float*);
 double* alloc_vec_double(int);
 double** alloc_mat_double(int, int);
 void release_vec_double(double*);
 void release_mat_double(double**);
 pixel_type* alloc_vec_pixel(int);
 pixel_type** alloc_mat_pixel(int, int);
 void release_vec_pixel(pixel_type*);
 void release_mat_pixel(pixel_type**);
 blob_type* alloc_vec_blob(int);
 void release_vec_blob(blob_type*);
 node_type* alloc_vec_node(int);
 node_type** alloc_mat_node(int, int);
 void release_vec_node(node_type*);
 void release_mat_node(node_type**);
 edge_type* alloc_vec_edge(int);
 void release_vec_edge(edge_type*);

#endif //ALLOC_MEM_H

---