Ignore:
Timestamp:
Jul 13, 2017, 11:01:58 AM (7 years ago)
Author:
meunier
Message:
  • Mise à jour NR2 et Rosenfeld
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r772 r826  
    1616#include <stddef.h>
    1717#include <stdlib.h>
    18 #include <math.h> // fabs
    1918
    2019#include "mypredef.h"
    … …  
    2726#include "nrsort1.h"
    2827
    29 /* ------------------------------------------------------------------------------ */
    30 IMAGE_EXPORT(void) extractnz_boundaries_ui8vector(uint8 *v, long nl, long nh, long *nlnz, long *nhnz)
    31 /* ------------------------------------------------------------------------------ */
    32 {
    33     long left = nl, right = nh;;
    34    
    35     while(!v[left ] && left  <= nh) left++;
    36     while(!v[right] && right >= nl) right--;
    37    
    38     *nlnz = left; *nhnz = right;
    39 }
    40 /* ------------------------------------------------------------------------------ */
    41 IMAGE_EXPORT(void) extractnz_boundaries_si16vector(sint16 *v, long nl, long nh, long *nlnz, long *nhnz)
    42 /* ------------------------------------------------------------------------------ */
    43 {
    44     long left = nl, right = nh;;
    45    
    46     while(!v[left ] && left  <= nh) left++;
    47     while(!v[right] && right >= nl) right--;
    48    
    49     *nlnz = left; *nhnz = right;
    50 }
    51 /* --------------------------------------------------------------------------------- */
    52 IMAGE_EXPORT(void) extractnz_boundaries_ui16vector(uint16 *v, long nl, long nh, long *nlnz, long *nhnz)
    53 /* --------------------------------------------------------------------------------- */
    54 {
    55     long left = nl, right = nh;;
    56    
    57     while(!v[left ] && left  <= nh) left++;
    58     while(!v[right] && right >= nl) right--;
    59    
    60     *nlnz = left; *nhnz = right;
    61 }
    62 /* ----------------------------------------------------------------------------- */
    63 IMAGE_EXPORT(void) extractnz_boundaries_si32vector(sint32 *v, long nl, long nh, long *nlnz, long *nhnz)
    64 /* ----------------------------------------------------------------------------- */
    65 {
    66     long left = nl, right = nh;;
    67    
    68     while(!v[left ] && left  <= nh) left++;
    69     while(!v[right] && right >= nl) right--;
    70    
    71     *nlnz = left; *nhnz = right;
    72 }
    73 /* ------------------------------------------------------------------------------- */
    74 IMAGE_EXPORT(void) extractnz_boundaries_ui32vector(uint32 *v, long nl, long nh, long *nlnz, long *nhnz)
    75 /* ------------------------------------------------------------------------------- */
    76 {
    77     long left = nl, right = nh;;
    78    
    79     while(!v[left ] && left  <= nh) left++;
    80     while(!v[right] && right >= nl) right--;
    81    
    82     *nlnz = left; *nhnz = right;
    83 }
    84 /* ---------------------------------------------------------------------------------------------- */
    85 IMAGE_EXPORT(void) extractnz_boundaries_f32vector(float32 *v, long nl, long nh, long *nlnz, long *nhnz, float32 epsillon)
    86 /* ---------------------------------------------------------------------------------------------- */
    87 {
    88     long left = nl, right = nh;;
    89    
    90     while(fabs(v[left ])<epsillon && left  <= nh) left++;
    91     while(fabs(v[right])<epsillon && right >= nl) right--;
    92    
    93     *nlnz = left; *nhnz = right;
    94 }
    95 /* ------------------------------------------------------------------------------------------------- */
    96 IMAGE_EXPORT(void) extractnz_boundaries_f64vector(float64 *v, long nl, long nh, long *nlnz, long *nhnz, float64 epsillon)
    97 /* ------------------------------------------------------------------------------------------------- */
    98 {
    99     long left = nl, right = nh;;
    100    
    101     while(fabs(v[left ])<epsillon && left  <= nh) left++;
    102     while(fabs(v[right])<epsillon && right >= nl) right--;
    103    
    104     *nlnz = left; *nhnz = right;
    105 }
    106 
    107 /* ------------------------------------------------------------------------------------ */
    108 IMAGE_EXPORT(void) sort_index_f64vector_selection(float64 *key, long nl, long nh, int *index)
    109 /* ------------------------------------------------------------------------------------ */
    110 {
    111         int i, j, pos, tmp;
    112         float64 x, min;
    113        
    114         for(i=nl; i<=nh; i++) {
    115                 index[i] = i-nl;
    116         }
    117        
    118         for(i=nl; i<nh; i++) {
    119                 min = key[i];
    120                 pos = i;
    121                 for(j=i+1; j<=nh; j++) {
    122                         x = key[j];
    123                         if(x < min) {
    124                                 min = x;
    125                                 pos = j;
    126                         }
    127                 }
    128                 key[pos] = key[i];
    129                 key[i]   = min;
    130                
    131                 tmp        = index[i];
    132                 index[i]   = index[pos];
    133                 index[pos] = tmp;
    134         }
    135 }
    136 /* ------------------------------------------------------------------------------------- */
    137 IMAGE_EXPORT(void) sort_index_ivector_selection_min(int *key, long nl, long nh, int *index)
    138 /* ------------------------------------------------------------------------------------- */
    139 {
    140         int i, j, pos, tmp;
    141         int x, min;
    142        
    143         for(i=nl; i<=nh; i++) {
    144                 //index[i] = i-nl;
    145                 index[i] = i;/**/
    146         }
    147        
    148         for(i=nl; i<nh; i++) {
    149                 min = key[i];
    150                 pos = i;
    151                 for(j=i+1; j<=nh; j++) {
    152                         x = key[j];
    153                         if(x < min) {
    154                                 min = x;
    155                                 pos = j;
    156                         }
    157                 }
    158                 key[pos] = key[i];
    159                 key[i]   = min;
    160                
    161                 tmp        = index[i];
    162                 index[i]   = index[pos];
    163                 index[pos] = tmp;
    164         }
    165 }
    166 /* ------------------------------------------------------------------------------------- */
    167 IMAGE_EXPORT(void) sort_index_ivector_selection_max(int *key, long nl, long nh, int *index)
    168 /* ------------------------------------------------------------------------------------- */
    169 {
    170         int i, j, pos, tmp;
    171         int x, max;
    172        
    173         for(i=nl; i<=nh; i++) {
    174                 //index[i] = i-nl;
    175                 index[i] = i;
    176         }
    177        
    178         for(i=nl; i<nh; i++) {
    179                 max = key[i];
    180                 pos = i;
    181                 for(j=i+1; j<=nh; j++) {
    182                         x = key[j];
    183                         if(x > max) {
    184                                 max = x;
    185                                 pos = j;
    186                         }
    187                 }
    188                 key[pos] = key[i];
    189                 key[i]   = max;
    190                
    191                 tmp        = index[i];
    192                 index[i]   = index[pos];
    193                 index[pos] = tmp;
    194         }
    195 }
    196 /* -------------------------------------------------------------------------------------- */
    197 IMAGE_EXPORT(void) sort_index_vector_selection_min(float *key, long nl, long nh, int *index)
    198 /* -------------------------------------------------------------------------------------- */
    199 {
    200         int i, j, pos, tmp;
    201         float x, min;
    202        
    203         for(i=nl; i<=nh; i++) {
    204                 //index[i] = i-nl;
    205                 index[i] = i;
    206         }
    207        
    208         for(i=nl; i<nh; i++) {
    209                 min = key[i];
    210                 pos = i;
    211                 for(j=i+1; j<=nh; j++) {
    212                         x = key[j];
    213                         if(x < min) {
    214                                 min = x;
    215                                 pos = j;
    216                         }
    217                 }
    218                 key[pos] = key[i];
    219                 key[i]   = min;
    220                
    221                 tmp        = index[i];
    222                 index[i]   = index[pos];
    223                 index[pos] = tmp;
    224         }
    225 }
    226 /* -------------------------------------------------------------------------------------- */
    227 IMAGE_EXPORT(void) sort_index_vector_selection_max(float *key, long nl, long nh, int *index)
    228 /* -------------------------------------------------------------------------------------- */
    229 {
    230         int i, j, pos, tmp;
    231         float x, max;
    232        
    233         for(i=nl; i<=nh; i++) {
    234                 //index[i] = i-nl;
    235                 index[i] = i;
    236         }
    237        
    238         for(i=nl; i<nh; i++) {
    239                 max = key[i];
    240                 pos = i;
    241                 for(j=i+1; j<=nh; j++) {
    242                         x = key[j];
    243                         if(x > max) {
    244                                 max = x;
    245                                 pos = j;
    246                         }
    247                 }
    248                 key[pos] = key[i];
    249                 key[i]   = max;
    250                
    251                 tmp        = index[i];
    252                 index[i]   = index[pos];
    253                 index[pos] = tmp;
    254         }
    255 }
    256 /* ---------------------------------------------------------------------------------------------- */
    257 IMAGE_EXPORT(void) sort_index_vector_selection_kmin(float *key, long nl, long nh, int *index, int k)
    258 /* ---------------------------------------------------------------------------------------------- */
    259 {
    260 /*
    261 * ATTENTION, ke tableau index DOIT etre initialise
    262         */
    263         int i, j, pos, tmp, il, ih;
    264         float x, min;
    265        
    266         il = nl;
    267         ih = il + k;
    268        
    269         /*for(i=il; i<=ih; i++) {
    270     index[i] = i-il;
    271 }*/
    272        
    273         for(i=il; i<ih; i++) {
    274                 min = key[i];
    275                 pos = i;
    276                 for(j=i+1; j<=nh; j++) {
    277                         x = key[j];
    278                         if(x < min) {
    279                                 min = x;
    280                                 pos = j;
    281                         }
    282                 }
    283                 key[pos] = key[i];
    284                 key[i]   = min;
    285                
    286                 tmp        = index[i];
    287                 index[i]   = index[pos];
    288                 index[pos] = tmp;
    289         }
    290 }
    291 /* --------------------------------------------------------------------------------------------- */
    292 IMAGE_EXPORT(void) sort_index_ivector_selection_kmin(int *key, long nl, long nh, int *index, int k)
    293 /* --------------------------------------------------------------------------------------------- */
    294 {
    295 /*
    296 * ATTENTION, ke tableau index DOIT etre initialise
    297         */
    298         int i, j, pos, tmp, il, ih;
    299         int x, min;
    300        
    301         il = nl;
    302         ih = il + k;
    303        
    304         /*for(i=il; i<=ih; i++) {
    305     index[i] = i-il;
    306 }*/
    307        
    308         for(i=il; i<ih; i++) {
    309                 min = key[i];
    310                 pos = i;
    311                 for(j=i+1; j<=nh; j++) {
    312                         x = key[j];
    313                         if(x < min) {
    314                                 min = x;
    315                                 pos = j;
    316                         }
    317                 }
    318                 key[pos] = key[i];
    319                 key[i]   = min;
    320                
    321                 tmp        = index[i];
    322                 index[i]   = index[pos];
    323                 index[pos] = tmp;
    324         }
    325 }
    326 /* ---------------------------------------------------------------------------------------------- */
    327 IMAGE_EXPORT(void) sort_index_vector_selection_kmax(float *key, long nl, long nh, int *index, int k)
    328 /* ---------------------------------------------------------------------------------------------- */
    329 {
    330 /*
    331 * ATTENTION, ke tableau index DOIT etre initialise
    332         */
    333         int i, j, pos, tmp, il, ih;
    334         float x, max;
    335        
    336         il = nl;
    337         ih = il + k;
    338        
    339         /*for(i=il; i<=ih; i++) {
    340     index[i] = i-il;
    341 }*/
    342        
    343         for(i=il; i<ih; i++) {
    344                 max = key[i];
    345                 pos = i;
    346                 for(j=i+1; j<=nh; j++) {
    347                         x = key[j];
    348                         if(x > max) {
    349                                 max = x;
    350                                 pos = j;
    351                         }
    352                 }
    353                 key[pos] = key[i];
    354                 key[i]   = max;
    355                
    356                 tmp        = index[i];
    357                 index[i]   = index[pos];
    358                 index[pos] = tmp;
    359         }
    360 }
    361 /* --------------------------------------------------------------------------------------------- */
    362 IMAGE_EXPORT(void) sort_index_ivector_selection_kmax(int *key, long nl, long nh, int *index, int k)
    363 /* --------------------------------------------------------------------------------------------- */
    364 {
    365 /*
    366 * ATTENTION, ke tableau index DOIT etre initialise
    367         */
    368         int i, j, pos, tmp, il, ih;
    369         int x, max;
    370        
    371         il = nl;
    372         ih = il + k;
    373        
    374         /*for(i=il; i<=ih; i++) {
    375     index[i] = i-il;
    376 }*/
    377        
    378         for(i=il; i<ih; i++) {
    379                 max = key[i];
    380                 pos = i;
    381                 for(j=i+1; j<=nh; j++) {
    382                         x = key[j];
    383                         if(x > max) {
    384                                 max = x;
    385                                 pos = j;
    386                         }
    387                 }
    388                 key[pos] = key[i];
    389                 key[i]   = max;
    390                
    391                 tmp        = index[i];
    392                 index[i]   = index[pos];
    393                 index[pos] = tmp;
    394         }
    395 }
    396 /* ------------------------------------------------------------------ */
    397 IMAGE_EXPORT(void) sort_bvector_selection_min(byte *v, long nl, long nh)
    398 /* ------------------------------------------------------------------ */
    399 {
    400         int i, j;
    401         int x, min, pos;
    402        
    403         for(i=nl; i<nh; i++) {
    404                 min = v[i];
    405                 pos = i;
    406                 for(j=i+1; j<=nh; j++) {
    407                         x = v[j];
    408                         if(x < min) {
    409                                 min = x;
    410                                 pos = j;
    411                         }
    412                 }
    413                 v[pos] = v[i];
    414                 v[i]   = min;
    415         }
    416 }
    417 /* -------------------------------------------------------------- */
    418 IMAGE_EXPORT(byte) select_bvector(byte *v, long nl, long nh, long k)
    419 /* -------------------------------------------------------------- */
    420 {
    421         int i, j, il, ih;
    422         int x, min, pos;
    423        
    424         il = nl;
    425         ih = il + k;
    426        
    427         for(i=il; i<ih; i++) {
    428                 min = v[i];
    429                 pos = i;
    430                 for(j=i+1; j<=nh; j++) {
    431                         x = v[j];
    432                         if(x < min) {
    433                                 min = x;
    434                                 pos = j;
    435                         }
    436                 }
    437                 v[pos] = v[i];
    438                 v[i]   = min;
    439         }
    440         return v[ih];
    441 }
    442 /* ----------------------------------------------------------------- */
    443 IMAGE_EXPORT(rgb8) select_rgb8vector(rgb8 *v, long nl, long nh, long k)
    444 /* ----------------------------------------------------------------- */
    445 {
    446         int i, j, il, ih;
    447        
    448         int rpos, gpos, bpos;
    449         rgb8 xi, xj;
    450         byte r,g,b;
    451         byte rmin, gmin, bmin;
    452        
    453         il = nl;
    454         ih = il + k;
    455        
    456         for(i=il; i<ih; i++) {
    457                
    458                 xi = v[i];
    459                 rmin = xi.r; gmin = xi.g; bmin = xi.b;
    460                 rpos = gpos = bpos = i;
    461                
    462                 for(j=i+1; j<=nh; j++) {
    463                         xj = v[j];
    464                         r = xj.r; g = xj.g; b = xj.b;
    465                         if(r < rmin) { rmin = r; rpos = j; }
    466                         if(g < gmin) { gmin = r; gpos = j; }
    467                         if(b < bmin) { bmin = r; bpos = j; }
    468                 }
    469                 v[rpos].r = v[i].r; v[i].r = rmin;
    470                 v[rpos].g = v[i].g; v[i].g = gmin;
    471                 v[rpos].b = v[i].b; v[i].b = bmin;
    472         }
    473         return v[ih];
    474 }
     28
     29#undef extractnz_boundaries_type_vector
     30#define extractnz_boundaries_type_vector(t) \
     31void short_name(t,extractnz_boundaries_,vector)(t * v, int32_t nl, int32_t nh, int32_t * nlnz, int32_t * nhnz) \
     32{                                      \
     33    int32_t left = nl;                 \
     34    int32_t right = nh;                \
     35    while (!v[left] && left <= nh) {   \
     36        left++;                        \
     37    }                                  \
     38    while (!v[right] && right >= nl) { \
     39        right--;                       \
     40    }                                  \
     41    *nlnz = left;                      \
     42    *nhnz = right;                     \
     43}
     44
     45
     46extractnz_boundaries_type_vector(int8_t);
     47extractnz_boundaries_type_vector(uint8_t);
     48extractnz_boundaries_type_vector(int16_t);
     49extractnz_boundaries_type_vector(uint16_t);
     50extractnz_boundaries_type_vector(int32_t);
     51extractnz_boundaries_type_vector(uint32_t);
     52extractnz_boundaries_type_vector(int64_t);
     53extractnz_boundaries_type_vector(uint64_t);
     54extractnz_boundaries_type_vector(float);
     55extractnz_boundaries_type_vector(double);
     56
     57
     58
     59void sort_index_f64vector_selection(double * key, int32_t nl, int32_t nh, int32_t * index)
     60{
     61    int32_t pos, tmp;
     62    double x, min;
     63
     64    for (int32_t i = nl; i<=nh; i++) {
     65        index[i] = i - nl;
     66    }
     67
     68    for (int32_t i = nl; i < nh; i++) {
     69        min = key[i];
     70        pos = i;
     71        for (int32_t j = i + 1; j <= nh; j++) {
     72            x = key[j];
     73            if (x < min) {
     74                min = x;
     75                pos = j;
     76            }
     77        }
     78        key[pos] = key[i];
     79        key[i]   = min;
     80
     81        tmp        = index[i];
     82        index[i]   = index[pos];
     83        index[pos] = tmp;
     84    }
     85}
     86
     87void sort_index_ivector_selection_min(int32_t * key, int32_t nl, int32_t nh, int32_t * index)
     88{
     89    int32_t pos, tmp;
     90    int32_t x, min;
     91
     92    for (int32_t i = nl; i <= nh; i++) {
     93        index[i] = i;
     94    }
     95
     96    for (int32_t i = nl; i < nh; i++) {
     97        min = key[i];
     98        pos = i;
     99        for (int32_t j = i + 1; j <= nh; j++) {
     100            x = key[j];
     101            if (x < min) {
     102                min = x;
     103                pos = j;
     104            }
     105        }
     106        key[pos] = key[i];
     107        key[i]   = min;
     108
     109        tmp        = index[i];
     110        index[i]   = index[pos];
     111        index[pos] = tmp;
     112    }
     113}
     114
     115void sort_index_ivector_selection_max(int32_t * key, int32_t nl, int32_t nh, int32_t * index)
     116{
     117    int32_t pos, tmp;
     118    int32_t x, max;
     119
     120    for (int32_t i = nl; i <= nh; i++) {
     121        index[i] = i;
     122    }
     123
     124    for (int32_t i = nl; i < nh; i++) {
     125        max = key[i];
     126        pos = i;
     127        for (int32_t j = i + 1; j <= nh; j++) {
     128            x = key[j];
     129            if (x > max) {
     130                max = x;
     131                pos = j;
     132            }
     133        }
     134        key[pos] = key[i];
     135        key[i]   = max;
     136
     137        tmp        = index[i];
     138        index[i]   = index[pos];
     139        index[pos] = tmp;
     140    }
     141}
     142
     143void sort_index_vector_selection_min(float * key, int32_t nl, int32_t nh, int32_t * index)
     144{
     145    int32_t pos, tmp;
     146    float x, min;
     147
     148    for (int32_t i = nl; i <= nh; i++) {
     149        index[i] = i;
     150    }
     151
     152    for (int32_t i = nl; i < nh; i++) {
     153        min = key[i];
     154        pos = i;
     155        for (int32_t j = i + 1; j <= nh; j++) {
     156            x = key[j];
     157            if (x < min) {
     158                min = x;
     159                pos = j;
     160            }
     161        }
     162        key[pos] = key[i];
     163        key[i]   = min;
     164
     165        tmp        = index[i];
     166        index[i]   = index[pos];
     167        index[pos] = tmp;
     168    }
     169}
     170
     171void sort_index_vector_selection_max(float * key, int32_t nl, int32_t nh, int32_t * index)
     172{
     173    int32_t pos, tmp;
     174    float x, max;
     175
     176    for (int32_t i = nl; i <= nh; i++) {
     177        index[i] = i;
     178    }
     179
     180    for (int32_t i = nl; i < nh; i++) {
     181        max = key[i];
     182        pos = i;
     183        for (int32_t j = i + 1; j <= nh; j++) {
     184            x = key[j];
     185            if (x > max) {
     186                max = x;
     187                pos = j;
     188            }
     189        }
     190        key[pos] = key[i];
     191        key[i]   = max;
     192
     193        tmp        = index[i];
     194        index[i]   = index[pos];
     195        index[pos] = tmp;
     196    }
     197}
     198
     199void sort_index_vector_selection_kmin(float * key, int32_t nl, int32_t nh, int32_t * index, int32_t k)
     200{
     201    /*
     202     * ATTENTION, le tableau index DOIT etre initialise
     203     * @QM : pourquoi est-ce commenté alors ?
     204     */
     205    int32_t pos, tmp, il, ih;
     206    float x, min;
     207
     208    il = nl;
     209    ih = il + k;
     210
     211    /*
     212    for(int32_t i = il; i <= ih; i++) {
     213        index[i] = i - il;
     214    }
     215    */
     216
     217    for (int32_t i = il; i < ih; i++) {
     218        min = key[i];
     219        pos = i;
     220        for (int32_t j = i + 1; j <= nh; j++) {
     221            x = key[j];
     222            if (x < min) {
     223                min = x;
     224                pos = j;
     225            }
     226        }
     227        key[pos] = key[i];
     228        key[i]   = min;
     229
     230        tmp        = index[i];
     231        index[i]   = index[pos];
     232        index[pos] = tmp;
     233    }
     234}
     235
     236void sort_index_ivector_selection_kmin(int32_t * key, int32_t nl, int32_t nh, int32_t * index, int32_t k)
     237{
     238    /*
     239     * ATTENTION, le tableau index DOIT etre initialise
     240     */
     241    int32_t pos, tmp, il, ih;
     242    int32_t x, min;
     243
     244    il = nl;
     245    ih = il + k;
     246
     247    /*
     248    for(int32_t i = il; i <= ih; i++) {
     249        index[i] = i - il;
     250    }
     251    */
     252
     253    for (int32_t i = il; i < ih; i++) {
     254        min = key[i];
     255        pos = i;
     256        for (int32_t j = i + 1; j <= nh; j++) {
     257            x = key[j];
     258            if (x < min) {
     259                min = x;
     260                pos = j;
     261            }
     262        }
     263        key[pos] = key[i];
     264        key[i]   = min;
     265
     266        tmp        = index[i];
     267        index[i]   = index[pos];
     268        index[pos] = tmp;
     269    }
     270}
     271
     272void sort_index_vector_selection_kmax(float * key, int32_t nl, int32_t nh, int32_t * index, int32_t k)
     273{
     274    /*
     275     * ATTENTION, le tableau index DOIT etre initialise
     276     */
     277    int32_t pos, tmp, il, ih;
     278    float x, max;
     279
     280    il = nl;
     281    ih = il + k;
     282
     283    /*
     284    for (int32_t i = il; i <= ih; i++) {
     285        index[i] = i - il;
     286    }
     287    */
     288
     289    for (int32_t i = il; i < ih; i++) {
     290        max = key[i];
     291        pos = i;
     292        for (int32_t j = i + 1; j <= nh; j++) {
     293            x = key[j];
     294            if (x > max) {
     295                max = x;
     296                pos = j;
     297            }
     298        }
     299        key[pos] = key[i];
     300        key[i]   = max;
     301
     302        tmp        = index[i];
     303        index[i]   = index[pos];
     304        index[pos] = tmp;
     305    }
     306}
     307
     308void sort_index_ivector_selection_kmax(int32_t * key, int32_t nl, int32_t nh, int32_t * index, int32_t k)
     309{
     310    /*
     311     * ATTENTION, le tableau index DOIT etre initialise
     312     */
     313    int32_t pos, tmp, il, ih;
     314    int32_t x, max;
     315
     316    il = nl;
     317    ih = il + k;
     318
     319    /*
     320    for (int32_t i = i l; i <= ih; i++) {
     321        index[i] = i - il;
     322    }
     323    */
     324
     325    for (int32_t i = il; i < ih; i++) {
     326        max = key[i];
     327        pos = i;
     328        for (int32_t j = i + 1; j <= nh; j++) {
     329            x = key[j];
     330            if (x > max) {
     331                max = x;
     332                pos = j;
     333            }
     334        }
     335        key[pos] = key[i];
     336        key[i]   = max;
     337
     338        tmp        = index[i];
     339        index[i]   = index[pos];
     340        index[pos] = tmp;
     341    }
     342}
     343
     344
     345void sort_bvector_selection_min(int8_t * v, int32_t nl, int32_t nh)
     346{
     347    int8_t x, min;
     348    int32_t pos;
     349
     350    for (int32_t i = nl; i < nh; i++) {
     351        min = v[i];
     352        pos = i;
     353        for (int32_t j = i + 1; j <= nh; j++) {
     354            x = v[j];
     355            if (x < min) {
     356                min = x;
     357                pos = j;
     358            }
     359        }
     360        v[pos] = v[i];
     361        v[i]   = min;
     362    }
     363}
     364
     365int8_t select_bvector(int8_t * v, int32_t nl, int32_t nh, int32_t k)
     366{
     367    int32_t il, ih;
     368    int8_t x, min, pos;
     369
     370    il = nl;
     371    ih = il + k;
     372
     373    for (int32_t i = il; i < ih; i++) {
     374        min = v[i];
     375        pos = i;
     376        for (int32_t j = i + 1; j <= nh; j++) {
     377            x = v[j];
     378            if (x < min) {
     379                min = x;
     380                pos = j;
     381            }
     382        }
     383        v[pos] = v[i];
     384        v[i]   = min;
     385    }
     386    return v[ih];
     387}
     388
     389rgb8 select_rgb8vector(rgb8 * v, int32_t nl, int32_t nh, int32_t k)
     390{
     391    int32_t il, ih;
     392    int32_t rpos, gpos, bpos;
     393
     394    rgb8 xi, xj;
     395    int8_t r, g, b;
     396    int8_t rmin, gmin, bmin;
     397
     398    il = nl;
     399    ih = il + k;
     400
     401    for (int32_t i = il; i < ih; i++) {
     402        xi = v[i];
     403        rmin = xi.r;
     404        gmin = xi.g;
     405        bmin = xi.b;
     406        rpos = gpos = bpos = i;
     407
     408        for (int32_t j = i + 1; j <= nh; j++) {
     409            xj = v[j];
     410            r = xj.r;
     411            g = xj.g;
     412            b = xj.b;
     413            if (r < rmin) {
     414                rmin = r;
     415                rpos = j;
     416            }
     417            if (g < gmin) {
     418                gmin = r;
     419                gpos = j;
     420            }
     421            if (b < bmin) {
     422                bmin = r;
     423                bpos = j;
     424            }
     425        }
     426        v[rpos].r = v[i].r;
     427        v[i].r = rmin;
     428        v[rpos].g = v[i].g;
     429        v[i].g = gmin;
     430        v[rpos].b = v[i].b;
     431        v[i].b = bmin;
     432    }
     433    return v[ih];
     434}
     435
     436// Local Variables:
     437// tab-width: 4
     438// c-basic-offset: 4
     439// c-file-offsets:((innamespace . 0)(inline-open . 0))
     440// indent-tabs-mode: nil
     441// End:
     442
     443// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=4:softtabstop=4
     444
Note: See TracChangeset for help on using the changeset viewer.