Ignore:
Timestamp:
May 6, 2016, 3:06:29 PM (9 years ago)
Author:
meunier
Message:
  • Added several versions of rosenfeld: { SLOW, FAST } x { FEATURES, NO_FEATURES }
  • Added native linux compilation support
  • Added a script to check results natively
  • Started to refactor nrc code
File:
1 edited

Legend:

Unmodified
Added
Removed

  • soft/giet_vm/applications/rosenfeld/nrc2/src/nralloc2x.c

    r772 r821  
    1717#include <malloc.h>
    1818#include <math.h> // fabs
    19 // #include <memory.h> // memcpy
    2019
     20#include "nrc_os_config.h"
    2121#include "mypredef.h"
    2222#include "nrtype.h"
    … …  
    2525#include "nrkernel.h"
    2626
    27 #include "nralloc1.h"
    28 #include "nralloc2.h"
    2927#include "nralloc2x.h"
    30 //#include "nrarith.h"
    3128
    32 /* ----------------------------------------------------------------------- */
    33 IMAGE_EXPORT(si16Point**) si16Pmatrix(long nrl, long nrh, long ncl, long nch)
    34 /* ----------------------------------------------------------------------- */
    35 {
    36     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    37     si16Point **m;
    38    
    39     /* allocate pointers to rows */
    40     m=(si16Point **) malloc((size_t)((nrow+NR_END)*sizeof(si16Point*)));
    41     if (!m) nrerror("allocation failure 1 in si16Pmatrix()");
    42     m += NR_END;
    43     m -= nrl;
    44    
    45     /* allocate rows and set pointers to them */
    46     m[nrl]=(si16Point *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(si16Point)));
    47     if (!m[nrl]) nrerror("allocation failure 2 in si16Pmatrix()");
    48     m[nrl] += NR_END;
    49     m[nrl] -= ncl;
    50    
    51     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    52    
    53     /* return pointer to array of pointers to rows */
    54     return m;
    55 }
    56 /* ----------------------------------------------------------------------- */
    57 IMAGE_EXPORT(ui16Point**) ui16Pmatrix(long nrl, long nrh, long ncl, long nch)
    58 /* ----------------------------------------------------------------------- */
    59 {
    60     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    61     ui16Point **m;
    62    
    63     /* allocate pointers to rows */
    64     m=(ui16Point **) malloc((size_t)((nrow+NR_END)*sizeof(ui16Point*)));
    65     if (!m) nrerror("allocation failure 1 in ui16Pmatrix()");
    66     m += NR_END;
    67     m -= nrl;
    68    
    69     /* allocate rows and set pointers to them */
    70     m[nrl]=(ui16Point *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(ui16Point)));
    71     if (!m[nrl]) nrerror("allocation failure 2 in ui16Pmatrix()");
    72     m[nrl] += NR_END;
    73     m[nrl] -= ncl;
    74    
    75     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    76    
    77     /* return pointer to array of pointers to rows */
    78     return m;
    79 }
    80 /* ----------------------------------------------------------------------- */
    81 IMAGE_EXPORT(si32Point**) si32Pmatrix(long nrl, long nrh, long ncl, long nch)
    82 /* ----------------------------------------------------------------------- */
    83 {
    84     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    85     si32Point **m;
    86    
    87     /* allocate pointers to rows */
    88     m=(si32Point **) malloc((size_t)((nrow+NR_END)*sizeof(si32Point*)));
    89     if (!m) nrerror("allocation failure 1 in si32Pmatrix()");
    90     m += NR_END;
    91     m -= nrl;
    92    
    93     /* allocate rows and set pointers to them */
    94     m[nrl]=(si32Point *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(si32Point)));
    95     if (!m[nrl]) nrerror("allocation failure 2 in si32Pmatrix()");
    96     m[nrl] += NR_END;
    97     m[nrl] -= ncl;
    98    
    99     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    100    
    101     /* return pointer to array of pointers to rows */
    102     return m;
    103 }
    104 /* ----------------------------------------------------------------------- */
    105 IMAGE_EXPORT(ui32Point**) ui32Pmatrix(long nrl, long nrh, long ncl, long nch)
    106 /* ----------------------------------------------------------------------- */
    107 {
    108     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    109     ui32Point **m;
    110    
    111     /* allocate pointers to rows */
    112     m=(ui32Point **) malloc((size_t)((nrow+NR_END)*sizeof(ui32Point*)));
    113     if (!m) nrerror("allocation failure 1 in ui32Pmatrix()");
    114     m += NR_END;
    115     m -= nrl;
    116    
    117     /* allocate rows and set pointers to them */
    118     m[nrl]=(ui32Point *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(ui32Point)));
    119     if (!m[nrl]) nrerror("allocation failure 2 in ui32Pmatrix()");
    120     m[nrl] += NR_END;
    121     m[nrl] -= ncl;
    122    
    123     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    124    
    125     /* return pointer to array of pointers to rows */
    126     return m;
    127 }
    128 /* ---------------------------------------------------------------------- */
    129 IMAGE_EXPORT(f32Point**) f32Pmatrix(long nrl, long nrh, long ncl, long nch)
    130 /* --------------------------------------------------------------------- */
    131 {
    132     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    133     f32Point **m;
    134    
    135     /* allocate pointers to rows */
    136     m=(f32Point **) malloc((size_t)((nrow+NR_END)*sizeof(f32Point*)));
    137     if (!m) nrerror("allocation failure 1 in f32Pmatrix()");
    138     m += NR_END;
    139     m -= nrl;
    140    
    141     /* allocate rows and set pointers to them */
    142     m[nrl]=(f32Point *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(f32Point)));
    143     if (!m[nrl]) nrerror("allocation failure 2 in f32Pmatrix()");
    144     m[nrl] += NR_END;
    145     m[nrl] -= ncl;
    146    
    147     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    148    
    149     /* return pointer to array of pointers to rows */
    150     return m;
    151 }
    152 /* ------------------------------------------------------------------------- */
    153 IMAGE_EXPORT(si16Triplet**) si16Tmatrix(long nrl, long nrh, long ncl, long nch)
    154 /* ------------------------------------------------------------------------- */
    155 {
    156     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    157     si16Triplet **m;
    158    
    159     /* allocate pointers to rows */
    160     m=(si16Triplet **) malloc((size_t)((nrow+NR_END)*sizeof(si16Triplet*)));
    161     if (!m) nrerror("allocation failure 1 in si16Tmatrix()");
    162     m += NR_END;
    163     m -= nrl;
    164    
    165     /* allocate rows and set pointers to them */
    166     m[nrl]=(si16Triplet *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(si16Triplet)));
    167     if (!m[nrl]) nrerror("allocation failure 2 in si16Tmatrix()");
    168     m[nrl] += NR_END;
    169     m[nrl] -= ncl;
    170    
    171     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    172    
    173     /* return pointer to array of pointers to rows */
    174     return m;
    175 }
    176 /* ----------------------------------------------------------------------- */
    177 IMAGE_EXPORT(ui16Triplet**) ui16Tmatrix(long nrl, long nrh, long ncl, long nch)
    178 /* ----------------------------------------------------------------------- */
    179 {
    180     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    181     ui16Triplet **m;
    182    
    183     /* allocate pointers to rows */
    184     m=(ui16Triplet **) malloc((size_t)((nrow+NR_END)*sizeof(ui16Triplet*)));
    185     if (!m) nrerror("allocation failure 1 in ui16Tmatrix()");
    186     m += NR_END;
    187     m -= nrl;
    188    
    189     /* allocate rows and set pointers to them */
    190     m[nrl]=(ui16Triplet *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(ui16Triplet)));
    191     if (!m[nrl]) nrerror("allocation failure 2 in ui16Tmatrix()");
    192     m[nrl] += NR_END;
    193     m[nrl] -= ncl;
    194    
    195     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    196    
    197     /* return pointer to array of pointers to rows */
    198     return m;
    199 }
    200 /* ----------------------------------------------------------------------- */
    201 IMAGE_EXPORT(si32Triplet**) si32Tmatrix(long nrl, long nrh, long ncl, long nch)
    202 /* ----------------------------------------------------------------------- */
    203 {
    204     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    205     si32Triplet **m;
    206    
    207     /* allocate pointers to rows */
    208     m=(si32Triplet**) malloc((size_t)((nrow+NR_END)*sizeof(si32Triplet*)));
    209     if (!m) nrerror("allocation failure 1 in si32Tmatrix()");
    210     m += NR_END;
    211     m -= nrl;
    212    
    213     /* allocate rows and set pointers to them */
    214     m[nrl]=(si32Triplet*) malloc((size_t)((nrow*ncol+NR_END)*sizeof(si32Triplet)));
    215     if (!m[nrl]) nrerror("allocation failure 2 in si32Tmatrix()");
    216     m[nrl] += NR_END;
    217     m[nrl] -= ncl;
    218    
    219     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    220    
    221     /* return pointer to array of pointers to rows */
    222     return m;
    223 }
    224 /* ----------------------------------------------------------------------- */
    225 IMAGE_EXPORT(ui32Triplet**) ui32Tmatrix(long nrl, long nrh, long ncl, long nch)
    226 /* ----------------------------------------------------------------------- */
    227 {
    228     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    229     ui32Triplet **m;
    230    
    231     /* allocate pointers to rows */
    232     m=(ui32Triplet **) malloc((size_t)((nrow+NR_END)*sizeof(ui32Triplet*)));
    233     if (!m) nrerror("allocation failure 1 in ui32Tmatrix()");
    234     m += NR_END;
    235     m -= nrl;
    236    
    237     /* allocate rows and set pointers to them */
    238     m[nrl]=(ui32Triplet *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(ui32Triplet)));
    239     if (!m[nrl]) nrerror("allocation failure 2 in ui32Tmatrix()");
    240     m[nrl] += NR_END;
    241     m[nrl] -= ncl;
    242    
    243     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    244    
    245     /* return pointer to array of pointers to rows */
    246     return m;
    247 }
    248 /* ---------------------------------------------------------------------- */
    249 IMAGE_EXPORT(f32Triplet**) f32Tmatrix(long nrl, long nrh, long ncl, long nch)
    250 /* --------------------------------------------------------------------- */
    251 {
    252     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1;
    253     f32Triplet **m;
    254    
    255     /* allocate pointers to rows */
    256     m=(f32Triplet **) malloc((size_t)((nrow+NR_END)*sizeof(f32Triplet*)));
    257     if (!m) nrerror("allocation failure 1 in f32Tmatrix()");
    258     m += NR_END;
    259     m -= nrl;
    260    
    261     /* allocate rows and set pointers to them */
    262     m[nrl]=(f32Triplet *) malloc((size_t)((nrow*ncol+NR_END)*sizeof(f32Triplet)));
    263     if (!m[nrl]) nrerror("allocation failure 2 in f32Tmatrix()");
    264     m[nrl] += NR_END;
    265     m[nrl] -= ncl;
    266    
    267     for(i=nrl+1;i<=nrh;i++) m[i]=m[i-1]+ncol;
    268    
    269     /* return pointer to array of pointers to rows */
    270     return m;
    271 }
    272 /* ---------------------------------------------------------------------------------- */
    273 IMAGE_EXPORT(void) free_si16Pmatrix(si16Point **m, long nrl, long nrh, long ncl, long nch)
    274 /* ---------------------------------------------------------------------------------- */
    275 /* free an si16Point matrix allocated by si16Pmatrix() */
    276 {
    277     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    278     free((FREE_ARG) (m+nrl-NR_END));
    279 }
    280 /* ---------------------------------------------------------------------------------- */
    281 IMAGE_EXPORT(void) free_ui16Pmatrix(ui16Point **m, long nrl, long nrh, long ncl, long nch)
    282 /* ---------------------------------------------------------------------------------- */
    283 /* free an ui16Point matrix allocated by ui16Pmatrix() */
    284 {
    285     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    286     free((FREE_ARG) (m+nrl-NR_END));
    287 }
    288 /* ------------------------------------------------------------------------------------ */
    289 IMAGE_EXPORT(void) free_si32Pmatrix(si32Point **m, long nrl, long nrh, long ncl, long nch)
    290 /* ------------------------------------------------------------------------------------ */
    291 {
    292     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    293     free((FREE_ARG) (m+nrl-NR_END));
    294 }
    295 /* ------------------------------------------------------------------------------------ */
    296 IMAGE_EXPORT(void) free_ui32Pmatrix(ui32Point **m, long nrl, long nrh, long ncl, long nch)
    297 /* ------------------------------------------------------------------------------------ */
    298 {
    299     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    300     free((FREE_ARG) (m+nrl-NR_END));
    301 }
    302 /* ---------------------------------------------------------------------------------- */
    303 IMAGE_EXPORT(void) free_f32Pmatrix(f32Point **m, long nrl, long nrh, long ncl, long nch)
    304 /* ---------------------------------------------------------------------------------- */
    305 /* free an f32Point matrix allocated by f32Pmatrix() */
    306 {
    307     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    308     free((FREE_ARG) (m+nrl-NR_END));
    309 }
    310 /* -------------------------------------------------------------------------------------- */
    311 IMAGE_EXPORT(void) free_si16Tmatrix(si16Triplet **m, long nrl, long nrh, long ncl, long nch)
    312 /* -------------------------------------------------------------------------------------- */
    313 /* free an si16Point matrix allocated by si16Pmatrix() */
    314 {
    315     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    316     free((FREE_ARG) (m+nrl-NR_END));
    317 }
    318 /* ---------------------------------------------------------------------------------- */
    319 IMAGE_EXPORT(void) free_ui16Tmatrix(ui16Triplet **m, long nrl, long nrh, long ncl, long nch)
    320 /* ---------------------------------------------------------------------------------- */
    321 /* free an ui16Point matrix allocated by ui16Pmatrix() */
    322 {
    323     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    324     free((FREE_ARG) (m+nrl-NR_END));
    325 }
    326 /* ------------------------------------------------------------------------------------ */
    327 IMAGE_EXPORT(void) free_si32Tmatrix(si32Triplet **m, long nrl, long nrh, long ncl, long nch)
    328 /* ------------------------------------------------------------------------------------ */
    329 {
    330     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    331     free((FREE_ARG) (m+nrl-NR_END));
    332 }
    333 /* -------------------------------------------------------------------------------------- */
    334 IMAGE_EXPORT(void) free_ui32Tmatrix(ui32Triplet **m, long nrl, long nrh, long ncl, long nch)
    335 /* -------------------------------------------------------------------------------------- */
    336 {
    337     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    338     free((FREE_ARG) (m+nrl-NR_END));
    339 }
    340 /* ------------------------------------------------------------------------------------ */
    341 IMAGE_EXPORT(void) free_f32Tmatrix(f32Triplet **m, long nrl, long nrh, long ncl, long nch)
    342 /* ------------------------------------------------------------------------------------ */
    343 /* free an f32Point matrix allocated by f32Pmatrix() */
    344 {
    345     free((FREE_ARG) (m[nrl]+ncl-NR_END));
    346     free((FREE_ARG) (m+nrl-NR_END));
    347 }
    34829
    34930/* ----------------- */
    35031/* --- trimatrix --- */
    35132/* ----------------- */
    352 /* ---------------------------------------------------------------------------- */
    353 IMAGE_EXPORT(byte**) btrimatrix(long nrl, long nrh, long ncl, long nch, long step)
    354 /* ---------------------------------------------------------------------------- */
    355 /* allocate an byte triangle-matrix with subscript range m[nrl..nrh][ncl..nch] */
    356 {
    357     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1, n = nrow * ncol + (nrow * (nrow-1) * step) / 2;
    358     // Attention, factorisation of n IS NOT PERMITTED : (nrow-1)step/2 is not even!!!
    359     byte **m;
    360    
    361     /* allocate pointers to rows */
    362     m=(byte **) malloc((size_t)((nrow+NR_END)*sizeof(byte*)));
    363     if (!m) nrerror("allocation failure 1 in btrimatrix()");
    364     m += NR_END;
    365     m -= nrl;
    366    
    367    
    368     /* allocate rows and set pointers to them */
    369     m[nrl]=(byte *) malloc((size_t)((n+NR_END)*sizeof(byte)));
    370     if (!m[nrl]) nrerror("allocation failure 2 in btrimatrix()");
    371     m[nrl] += NR_END;
    372     m[nrl] -= ncl;
    373    
    374     for(i=nrl+1;i<=nrh;i++) { m[i]=m[i-1]+ncol; ncol += step; }
    375    
    376     /* return pointer to array of pointers to rows */
    377     return m;
     33
     34
     35#undef type_trimatrix
     36#define type_trimatrix(t) \
     37t ** short_name(t,,trimatrix)(int32_t nrl, int32_t nrh, int32_t ncl, int32_t nch, int32_t step) \
     38/* allocate an byte triangle-matrix with subscript range m[nrl..nrh][ncl..nch] */               \
     39{                                                                                               \
     40    int32_t nrow = nrh - nrl + 1;                                                               \
     41    int32_t ncol = nch - ncl + 1;                                                               \
     42    int n = nrow * ncol + (nrow * (nrow - 1) * step) / 2;                                       \
     43    /* Attention, factorisation of n IS NOT PERMITTED : (nrow - 1) step / 2 is not even!!! */   \
     44    t ** m;                                                                                     \
     45    /* allocate pointers to rows */                                                             \
     46    m = malloc((nrow + NR_END) * sizeof(t *));                                                  \
     47    if (m == NULL) {                                                                            \
     48        nrerror("*** Error: allocation failure in %s\n", __func__);                             \
     49    }                                                                                           \
     50    m += NR_END;                                                                                \
     51    m -= nrl;                                                                                   \
     52    /* allocate rows and set pointers to them */                                                \
     53    m[nrl] = malloc(((n + NR_END) * sizeof(t)));                                                \
     54    if (m[nrl] == NULL) {                                                                       \
     55        nrerror("*** Error: allocation failure in %s\n", __func__);                             \
     56    }                                                                                           \
     57    m[nrl] += NR_END;                                                                           \
     58    m[nrl] -= ncl;                                                                              \
     59    for (int32_t i = nrl + 1; i <= nrh;i++) {                                                   \
     60        m[i] = m[i - 1] + ncol;                                                                 \
     61        ncol += step;                                                                           \
     62    }                                                                                           \
     63    /* return pointer to array of pointers to rows */                                           \
     64    return m;                                                                                   \
    37865}
    379 /* --------------------------------------------------------------------------------- */
    380 IMAGE_EXPORT(sint16**) si16trimatrix(long nrl, long nrh, long ncl, long nch, long step)
    381 /* --------------------------------------------------------------------------------- */
    382 /* allocate an i16 triangle-matrix with subscript range m[nrl..nrh][ncl..nch] */
    383 {
    384     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1, n = nrow * ncol + (nrow * (nrow-1) * step) / 2;
    385     // Attention, factorisation of n IS NOT PERMITTED : (nrow-1)step/2 is not even!!!
    386     sint16 **m;
    387    
    388     /* allocate pointers to rows */
    389     m=(sint16 **) malloc((size_t)((nrow+NR_END)*sizeof(sint16*)));
    390     if (!m) nrerror("allocation failure 1 in i16trimatrix()");
    391     m += NR_END;
    392     m -= nrl;
    393    
    394    
    395     /* allocate rows and set pointers to them */
    396     m[nrl]=(int16*) malloc((size_t)((n+NR_END)*sizeof(int16)));
    397     if (!m[nrl]) nrerror("allocation failure 2 in i16trimatrix()");
    398     m[nrl] += NR_END;
    399     m[nrl] -= ncl;
    400    
    401     for(i=nrl+1;i<=nrh;i++) { m[i]=m[i-1]+ncol; ncol += step; }
    402    
    403     /* return pointer to array of pointers to rows */
    404     return m;
    405 }
    406 /* --------------------------------------------------------------------------------- */
    407 IMAGE_EXPORT(uint16**) ui16trimatrix(long nrl, long nrh, long ncl, long nch, long step)
    408 /* --------------------------------------------------------------------------------- */
    409 /* allocate an i16 triangle-matrix with subscript range m[nrl..nrh][ncl..nch] */
    410 {
    411     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1, n = nrow * ncol + (nrow * (nrow-1) * step) / 2;
    412     // Attention, factorisation of n IS NOT PERMITTED : (nrow-1)step/2 is not even!!!
    413     uint16 **m;
    414    
    415     /* allocate pointers to rows */
    416     m=(uint16 **) malloc((size_t)((nrow+NR_END)*sizeof(uint16*)));
    417     if (!m) nrerror("allocation failure 1 in ui16trimatrix()");
    418     m += NR_END;
    419     m -= nrl;
    420    
    421    
    422     /* allocate rows and set pointers to them */
    423     m[nrl]=(uint16*) malloc((size_t)((n+NR_END)*sizeof(uint16)));
    424     if (!m[nrl]) nrerror("allocation failure 2 in i16trimatrix()");
    425     m[nrl] += NR_END;
    426     m[nrl] -= ncl;
    427    
    428     for(i=nrl+1;i<=nrh;i++) { m[i]=m[i-1]+ncol; ncol += step; }
    429    
    430     /* return pointer to array of pointers to rows */
    431     return m;
    432 }
    433 /* --------------------------------------------------------------------------------- */
    434 IMAGE_EXPORT(sint32**) si32trimatrix(long nrl, long nrh, long ncl, long nch, long step)
    435 /* --------------------------------------------------------------------------------- */
    436 /* allocate an i32 triangle-matrix with subscript range m[nrl..nrh][ncl..nch] */
    437 {
    438     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1, n = nrow * ncol + (nrow * (nrow-1) * step) / 2;
    439     // Attention, factorisation of n IS NOT PERMITTED : (nrow-1)step/2 is not even!!!
    440     sint32 **m;
    441    
    442     /* allocate pointers to rows */
    443     m=(sint32 **) malloc((size_t)((nrow+NR_END)*sizeof(sint32*)));
    444     if (!m) nrerror("allocation failure 1 in si32trimatrix()");
    445     m += NR_END;
    446     m -= nrl;
    447    
    448    
    449     /* allocate rows and set pointers to them */
    450     m[nrl]=(sint32*) malloc((size_t)((n+NR_END)*sizeof(sint32)));
    451     if (!m[nrl]) nrerror("allocation failure 2 in si32trimatrix()");
    452     m[nrl] += NR_END;
    453     m[nrl] -= ncl;
    454    
    455     for(i=nrl+1;i<=nrh;i++) { m[i]=m[i-1]+ncol; ncol += step; }
    456    
    457     /* return pointer to array of pointers to rows */
    458     return m;
    459 }
    460 /* -------------------------------------------------------------------------------- */
    461 IMAGE_EXPORT(uint32**) i32trimatrix(long nrl, long nrh, long ncl, long nch, long step)
    462 /* -------------------------------------------------------------------------------- */
    463 /* allocate an i32 triangle-matrix with subscript range m[nrl..nrh][ncl..nch] */
    464 {
    465     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1, n = nrow * ncol + (nrow * (nrow-1) * step) / 2;
    466     // Attention, factorisation of n IS NOT PERMITTED : (nrow-1)step/2 is not even!!!
    467     uint32 **m;
    468    
    469     /* allocate pointers to rows */
    470     m=(uint32 **) malloc((size_t)((nrow+NR_END)*sizeof(uint32*)));
    471     if (!m) nrerror("allocation failure 1 in ui32trimatrix()");
    472     m += NR_END;
    473     m -= nrl;
    474    
    475    
    476     /* allocate rows and set pointers to them */
    477     m[nrl]=(uint32*) malloc((size_t)((n+NR_END)*sizeof(uint32)));
    478     if (!m[nrl]) nrerror("allocation failure 2 in i32trimatrix()");
    479     m[nrl] += NR_END;
    480     m[nrl] -= ncl;
    481    
    482     for(i=nrl+1;i<=nrh;i++) { m[i]=m[i-1]+ncol; ncol += step; }
    483    
    484     /* return pointer to array of pointers to rows */
    485     return m;
    486 }
    487 /* --------------------------------------------------------------------------------- */
    488 IMAGE_EXPORT(float32**) f32trimatrix(long nrl, long nrh, long ncl, long nch, long step)
    489 /* --------------------------------------------------------------------------------- */
    490 /* allocate an f32 triangle-matrix with subscript range m[nrl..nrh][ncl..nch] */
    491 {
    492     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1, n = nrow * ncol + (nrow * (nrow-1) * step) / 2;
    493     // Attention, factorisation of n IS NOT PERMITTED : (nrow-1)step/2 is not even!!!
    494     float32 **m;
    495    
    496     /* allocate pointers to rows */
    497     m=(float32 **) malloc((size_t)((nrow+NR_END)*sizeof(float32*)));
    498     if (!m) nrerror("allocation failure 1 in f32trimatrix()");
    499     m += NR_END;
    500     m -= nrl;
    501    
    502    
    503     /* allocate rows and set pointers to them */
    504     m[nrl]=(float32*) malloc((size_t)((n+NR_END)*sizeof(float32)));
    505     if (!m[nrl]) nrerror("allocation failure 2 in f32trimatrix()");
    506     m[nrl] += NR_END;
    507     m[nrl] -= ncl;
    508    
    509     for(i=nrl+1;i<=nrh;i++) { m[i]=m[i-1]+ncol; ncol += step; }
    510    
    511     /* return pointer to array of pointers to rows */
    512     return m;
    513 }
    514 /* --------------------------------------------------------------------------------- */
    515 IMAGE_EXPORT(float64**) f64trimatrix(long nrl, long nrh, long ncl, long nch, long step)
    516 /* --------------------------------------------------------------------------------- */
    517 /* allocate an f64 triangle-matrix with subscript range m[nrl..nrh][ncl..nch] */
    518 {
    519     long i, nrow=nrh-nrl+1,ncol=nch-ncl+1, n = nrow * ncol + (nrow * (nrow-1) * step) / 2;
    520     // Attention, factorisation of n IS NOT PERMITTED : (nrow-1)step/2 is not even!!!
    521     float64 **m;
    522    
    523     /* allocate pointers to rows */
    524     m=(float64 **) malloc((size_t)((nrow+NR_END)*sizeof(float64*)));
    525     if (!m) nrerror("allocation failure 1 in f64trimatrix()");
    526     m += NR_END;
    527     m -= nrl;
    528    
    529    
    530     /* allocate rows and set pointers to them */
    531     m[nrl]=(float64*) malloc((size_t)((n+NR_END)*sizeof(float64)));
    532     if (!m[nrl]) nrerror("allocation failure 2 in f64trimatrix()");
    533     m[nrl] += NR_END;
    534     m[nrl] -= ncl;
    535    
    536     for(i=nrl+1;i<=nrh;i++) { m[i]=m[i-1]+ncol; ncol += step; }
    537    
    538     /* return pointer to array of pointers to rows */
    539     return m;
    540 }
     66
     67
     68type_trimatrix(int8_t);
     69type_trimatrix(uint8_t);
     70type_trimatrix(int16_t);
     71type_trimatrix(uint16_t);
     72type_trimatrix(int32_t);
     73type_trimatrix(uint32_t);
     74type_trimatrix(float);
     75type_trimatrix(double);
     76
     77// Local Variables:
     78// tab-width: 4
     79// c-basic-offset: 4
     80// c-file-offsets:((innamespace . 0)(inline-open . 0))
     81// indent-tabs-mode: nil
     82// End:
     83// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
     84
Note: See TracChangeset for help on using the changeset viewer.