Fulguro: /home/christophe/src/fulguro/trunk/src/core/flgrCoreCopy.c Source File

00001 /****************************************************************
00002  * Fulguro
00003  * Copyright (C) 2004 Christophe Clienti
00004  *
00005  * This library is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU Lesser General Public
00007  * License as published by the Free Software Foundation; either
00008  * version 2 of the License, or (at your option) any later version.
00009  *
00010  * This library is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00013  * Lesser General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU Lesser General Public
00016  * License along with this library; if not, write to the
00017  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00018  * Boston, MA 02111-1307, USA.
00019  ***************************************************************/
00020 
00021 #include <stdio.h>
00022 #include <stdlib.h>
00023 #include <string.h>
00024 #include "flgrCoreMalloc.h"
00025 #include "flgrCoreData.h"
00026 #include "flgrCoreCopy.h"
00027 #include "flgrCoreDispatch.h"
00028 #include "flgrCoreDataIO.h"
00029 
00037 #define BVSZ (8*sizeof(fgBIT))
00038 
00039 #define FLGR_MACRO_COPY1D_SAME_TYPE                 \
00040   memcpy(datdest->array, datsrc->array, (datdest->bps*datdest->length*datdest->spp)/8)
00041 
00042 #define FLGR_MACRO_COPY1D_BIT                       \
00043   memcpy(datdest->array,datsrc->array,( ( ((datdest->length*datdest->spp) / BVSZ) + 1) * BVSZ ) / 8 )
00044 
00045 
00046 #define FLGR_MACRO_COPY1D(dtypeDest, dtypeSrc)          \
00047   int j,length = datdest->length*datdest->spp;          \
00048   dtypeDest var;                        \
00049   dtypeDest *dar = (dtypeDest *) datdest->array;        \
00050   dtypeSrc *sar = (dtypeSrc *) datsrc->array;           \
00051                                 \
00052                     \
00053                                 \
00054   for(j=0; j<length ; j++) {                    \
00055     var = (dtypeDest) flgr1d_get_data_array_##dtypeSrc(sar,j);  \
00056     flgr1d_set_data_array_##dtypeDest(dar,j,var);       \
00057   }                             \
00058   return
00059 
00060 #define FLGR_MACRO_COPY1D_BIT_DTYPE(dtypeSrc)           \
00061   int j,k;                          \
00062   int bps = sizeof(fgBIT)<<3;                   \
00063   int mlength = (datdest->length*datdest->spp) % bps;       \
00064   int length = (datdest->length*datdest->spp) - mlength;    \
00065   dtypeSrc *psrc;                       \
00066   fgBIT *pdest;                         \
00067   fgBIT bitval=0;                       \
00068   fgBIT word = 0;                       \
00069                     \
00070                                 \
00071                                 \
00072   psrc = (dtypeSrc*) datsrc->array;             \
00073   pdest = (fgBIT*) datdest->array;              \
00074   j=0;                              \
00075                                 \
00076   while(j<length) {                     \
00077     word=0;                         \
00078     for(k=0 ; k<bps ; k++) {                    \
00079       bitval = ((psrc[j++]!=0) ? 1 : 0);            \
00080       word = (word<<1) | bitval;                \
00081     }                               \
00082     *pdest++=word;                      \
00083   }                             \
00084                                 \
00085   word=0;                           \
00086   for(k=0;k<mlength;k++) {                  \
00087     bitval = ((psrc[j++]!=0) ? 1 : 0);              \
00088     word = (word<<1) | bitval;                  \
00089   }                             \
00090   if(mlength!=0)                        \
00091     *pdest++=word<<(bps-mlength);               \
00092                                 \
00093   return
00094 
00095 #define FLGR_MACRO_COPY1D_DTYPE_BIT(dtypeDest)          \
00096   int j,k;                          \
00097   int bps = sizeof(fgBIT)<<3;                   \
00098   int mlength = (datdest->length*datdest->spp) % bps;       \
00099   int length = (datdest->length*datdest->spp) - mlength;    \
00100   dtypeDest *pdest;                     \
00101   fgBIT *psrc;                          \
00102   fgBIT word = 0;                       \
00103   fgBIT carry = ((fgBIT) 1)<<(bps-1);               \
00104                     \
00105                                 \
00106                                 \
00107   psrc = (fgBIT*) datsrc->array;                \
00108   pdest = (dtypeDest*) datdest->array;              \
00109   j=0;                              \
00110                                 \
00111   while(j<length) {                     \
00112     word = *psrc++;                     \
00113     for(k=0 ; k<bps ; k++) {                    \
00114       pdest[j++]=(dtypeDest) ((word & carry)>>(bps-1));     \
00115       word = word <<1;                      \
00116     }                               \
00117   }                             \
00118                                 \
00119   word = *psrc;                         \
00120   for(k=0 ; k<mlength ; k++) {                  \
00121     pdest[j++]=(dtypeDest) ((word & carry)>>(bps-1));       \
00122     word = word <<1;                        \
00123   }                             \
00124   return
00125 
00126 
00127 
00128 
00129 void flgr1d_copy_fgBIT_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00130   FLGR_MACRO_COPY1D_BIT;
00131 }
00132 void flgr1d_copy_fgUINT8_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00133   FLGR_MACRO_COPY1D_DTYPE_BIT(fgUINT8);
00134 }
00135 void flgr1d_copy_fgUINT16_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00136   FLGR_MACRO_COPY1D_DTYPE_BIT(fgUINT16);
00137 }
00138 void flgr1d_copy_fgUINT32_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00139   FLGR_MACRO_COPY1D_DTYPE_BIT(fgUINT32);
00140 }
00141 void flgr1d_copy_fgINT8_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00142   FLGR_MACRO_COPY1D_DTYPE_BIT(fgINT8);
00143 }
00144 void flgr1d_copy_fgINT16_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00145   FLGR_MACRO_COPY1D_DTYPE_BIT(fgINT16);
00146 }
00147 void flgr1d_copy_fgINT32_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00148   FLGR_MACRO_COPY1D_DTYPE_BIT(fgINT32);
00149 }
00150 void flgr1d_copy_fgFLOAT32_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00151   FLGR_MACRO_COPY1D_DTYPE_BIT(fgFLOAT32);
00152 }
00153 void flgr1d_copy_fgFLOAT64_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00154   FLGR_MACRO_COPY1D_DTYPE_BIT(fgFLOAT64);
00155 }
00156 
00157 
00158 
00159 
00160 void flgr1d_copy_fgBIT_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00161   FLGR_MACRO_COPY1D_BIT_DTYPE(fgUINT8);
00162 }
00163 void flgr1d_copy_fgUINT8_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00164   FLGR_MACRO_COPY1D_SAME_TYPE;
00165 }
00166 void flgr1d_copy_fgUINT16_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00167   FLGR_MACRO_COPY1D(fgUINT16,fgUINT8);
00168 }
00169 void flgr1d_copy_fgUINT32_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00170   FLGR_MACRO_COPY1D(fgUINT32,fgUINT8);
00171 }
00172 void flgr1d_copy_fgINT8_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00173   FLGR_MACRO_COPY1D(fgINT8,fgUINT8);
00174 }
00175 void flgr1d_copy_fgINT16_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00176   FLGR_MACRO_COPY1D(fgINT16,fgUINT8);
00177 }
00178 void flgr1d_copy_fgINT32_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00179   FLGR_MACRO_COPY1D(fgINT32,fgUINT8);
00180 }
00181 void flgr1d_copy_fgFLOAT32_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00182   FLGR_MACRO_COPY1D(fgFLOAT32,fgUINT8);
00183 }
00184 void flgr1d_copy_fgFLOAT64_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00185   FLGR_MACRO_COPY1D(fgFLOAT64,fgUINT8);
00186 }
00187 
00188 
00189 
00190 
00191 void flgr1d_copy_fgBIT_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00192   FLGR_MACRO_COPY1D_BIT_DTYPE(fgUINT16);
00193 }
00194 void flgr1d_copy_fgUINT8_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00195   FLGR_MACRO_COPY1D(fgUINT8,fgUINT16);
00196 }
00197 void flgr1d_copy_fgUINT16_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00198   FLGR_MACRO_COPY1D_SAME_TYPE;
00199 }
00200 void flgr1d_copy_fgUINT32_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00201   FLGR_MACRO_COPY1D(fgUINT32,fgUINT16);
00202 }
00203 void flgr1d_copy_fgINT8_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00204   FLGR_MACRO_COPY1D(fgINT8,fgUINT16);
00205 }
00206 void flgr1d_copy_fgINT16_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00207   FLGR_MACRO_COPY1D(fgINT16,fgUINT16);
00208 }
00209 void flgr1d_copy_fgINT32_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00210   FLGR_MACRO_COPY1D(fgINT32,fgUINT16);
00211 }
00212 void flgr1d_copy_fgFLOAT32_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00213   FLGR_MACRO_COPY1D(fgFLOAT32,fgUINT16);
00214 }
00215 void flgr1d_copy_fgFLOAT64_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00216   FLGR_MACRO_COPY1D(fgFLOAT64,fgUINT16);
00217 }
00218 
00219 
00220 
00221 
00222 void flgr1d_copy_fgBIT_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00223   FLGR_MACRO_COPY1D_BIT_DTYPE(fgUINT32);
00224 }
00225 void flgr1d_copy_fgUINT8_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00226   FLGR_MACRO_COPY1D(fgUINT8,fgUINT32);
00227 }
00228 void flgr1d_copy_fgUINT16_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00229   FLGR_MACRO_COPY1D(fgUINT16,fgUINT32);
00230 }
00231 void flgr1d_copy_fgUINT32_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00232   FLGR_MACRO_COPY1D_SAME_TYPE;
00233 }
00234 void flgr1d_copy_fgINT8_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00235   FLGR_MACRO_COPY1D(fgINT8,fgUINT32);
00236 }
00237 void flgr1d_copy_fgINT16_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00238   FLGR_MACRO_COPY1D(fgINT16,fgUINT32);
00239 }
00240 void flgr1d_copy_fgINT32_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00241   FLGR_MACRO_COPY1D(fgINT32,fgUINT32);
00242 }
00243 void flgr1d_copy_fgFLOAT32_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00244   FLGR_MACRO_COPY1D(fgFLOAT32,fgUINT32);
00245 }
00246 void flgr1d_copy_fgFLOAT64_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00247   FLGR_MACRO_COPY1D(fgFLOAT64,fgUINT32);
00248 }
00249 
00250 
00251 
00252 
00253 void flgr1d_copy_fgBIT_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00254   FLGR_MACRO_COPY1D_BIT_DTYPE(fgINT8);
00255 }
00256 void flgr1d_copy_fgUINT8_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00257   FLGR_MACRO_COPY1D(fgUINT8,fgINT8);
00258 }
00259 void flgr1d_copy_fgUINT16_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00260   FLGR_MACRO_COPY1D(fgUINT16,fgINT8);
00261 }
00262 void flgr1d_copy_fgUINT32_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00263   FLGR_MACRO_COPY1D(fgUINT32,fgINT8);
00264 }
00265 void flgr1d_copy_fgINT8_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00266   FLGR_MACRO_COPY1D_SAME_TYPE;
00267 }
00268 void flgr1d_copy_fgINT16_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00269   FLGR_MACRO_COPY1D(fgINT16,fgINT8);
00270 }
00271 void flgr1d_copy_fgINT32_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00272   FLGR_MACRO_COPY1D(fgINT32,fgINT8);
00273 }
00274 void flgr1d_copy_fgFLOAT32_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00275   FLGR_MACRO_COPY1D(fgFLOAT32,fgINT8);
00276 }
00277 void flgr1d_copy_fgFLOAT64_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00278   FLGR_MACRO_COPY1D(fgFLOAT64,fgINT8);
00279 }
00280 
00281 
00282 
00283 
00284 void flgr1d_copy_fgBIT_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00285   FLGR_MACRO_COPY1D_BIT_DTYPE(fgINT16);
00286 }
00287 void flgr1d_copy_fgUINT8_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00288   FLGR_MACRO_COPY1D(fgUINT8,fgINT16);
00289 }
00290 void flgr1d_copy_fgUINT16_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00291   FLGR_MACRO_COPY1D(fgUINT16,fgINT16);
00292 }
00293 void flgr1d_copy_fgUINT32_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00294   FLGR_MACRO_COPY1D(fgUINT32,fgINT16);
00295 }
00296 void flgr1d_copy_fgINT8_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00297   FLGR_MACRO_COPY1D(fgINT8,fgINT16);
00298 }
00299 void flgr1d_copy_fgINT16_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00300   FLGR_MACRO_COPY1D_SAME_TYPE;
00301 }
00302 void flgr1d_copy_fgINT32_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00303   FLGR_MACRO_COPY1D(fgINT32,fgINT16);
00304 }
00305 void flgr1d_copy_fgFLOAT32_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00306   FLGR_MACRO_COPY1D(fgFLOAT32,fgINT16);
00307 }
00308 void flgr1d_copy_fgFLOAT64_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00309   FLGR_MACRO_COPY1D(fgFLOAT64,fgINT16);
00310 }
00311 
00312 
00313 
00314 
00315 void flgr1d_copy_fgBIT_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00316   FLGR_MACRO_COPY1D_BIT_DTYPE(fgINT32);
00317 }
00318 void flgr1d_copy_fgUINT8_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00319   FLGR_MACRO_COPY1D(fgUINT8,fgINT32);
00320 }
00321 void flgr1d_copy_fgUINT16_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00322   FLGR_MACRO_COPY1D(fgUINT16,fgINT32);
00323 }
00324 void flgr1d_copy_fgUINT32_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00325   FLGR_MACRO_COPY1D(fgUINT32,fgINT32);
00326 }
00327 void flgr1d_copy_fgINT8_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00328   FLGR_MACRO_COPY1D(fgINT8,fgINT32);
00329 }
00330 void flgr1d_copy_fgINT16_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00331   FLGR_MACRO_COPY1D(fgINT16,fgINT32);
00332 }
00333 void flgr1d_copy_fgINT32_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00334   FLGR_MACRO_COPY1D_SAME_TYPE;
00335 }
00336 void flgr1d_copy_fgFLOAT32_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00337   FLGR_MACRO_COPY1D(fgFLOAT32,fgINT32);
00338 }
00339 void flgr1d_copy_fgFLOAT64_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00340   FLGR_MACRO_COPY1D(fgFLOAT64,fgINT32);
00341 }
00342 
00343 
00344 
00345 
00346 void flgr1d_copy_fgBIT_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00347   FLGR_MACRO_COPY1D_BIT_DTYPE(fgFLOAT32);
00348 }
00349 void flgr1d_copy_fgUINT8_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00350   FLGR_MACRO_COPY1D(fgUINT8,fgFLOAT32);
00351 }
00352 void flgr1d_copy_fgUINT16_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00353   FLGR_MACRO_COPY1D(fgUINT16,fgFLOAT32);
00354 }
00355 void flgr1d_copy_fgUINT32_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00356   FLGR_MACRO_COPY1D(fgUINT32,fgFLOAT32);
00357 }
00358 void flgr1d_copy_fgINT8_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00359   FLGR_MACRO_COPY1D(fgINT8,fgFLOAT32);
00360 }
00361 void flgr1d_copy_fgINT16_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00362   FLGR_MACRO_COPY1D(fgINT16,fgFLOAT32);
00363 }
00364 void flgr1d_copy_fgINT32_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00365   FLGR_MACRO_COPY1D(fgINT32,fgFLOAT32);
00366 }
00367 void flgr1d_copy_fgFLOAT32_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00368   FLGR_MACRO_COPY1D_SAME_TYPE;
00369 }
00370 void flgr1d_copy_fgFLOAT64_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00371   FLGR_MACRO_COPY1D(fgFLOAT64,fgFLOAT32);
00372 }
00373 
00374 
00375 
00376 
00377 void flgr1d_copy_fgBIT_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00378   FLGR_MACRO_COPY1D_BIT_DTYPE(fgFLOAT64);
00379 }
00380 void flgr1d_copy_fgUINT8_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00381   FLGR_MACRO_COPY1D(fgUINT8,fgFLOAT64);
00382 }
00383 void flgr1d_copy_fgUINT16_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00384   FLGR_MACRO_COPY1D(fgUINT16,fgFLOAT64);
00385 }
00386 void flgr1d_copy_fgUINT32_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00387   FLGR_MACRO_COPY1D(fgUINT32,fgFLOAT64);
00388 }
00389 void flgr1d_copy_fgINT8_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00390   FLGR_MACRO_COPY1D(fgINT8,fgFLOAT64);
00391 }
00392 void flgr1d_copy_fgINT16_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00393   FLGR_MACRO_COPY1D(fgINT16,fgFLOAT64);
00394 }
00395 void flgr1d_copy_fgINT32_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00396   FLGR_MACRO_COPY1D(fgINT32,fgFLOAT64);
00397 }
00398 void flgr1d_copy_fgFLOAT32_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00399   FLGR_MACRO_COPY1D(fgFLOAT32,fgFLOAT64);
00400 }
00401 void flgr1d_copy_fgFLOAT64_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00402   FLGR_MACRO_COPY1D_SAME_TYPE;
00403 }
00404 
00405 
00406 
00407 
00408 
00410 // Macro for copying considering a fix type for source
00412 #define FLGR_MACRO_COPY1D_SRC_FIX_TYPE(dtype_src,dtype1,dtype2,     \
00413                        dtype3,dtype4,dtype5,dtype6, \
00414                        dtype7,dtype8,dtype9)        \
00415                                     \
00416   if(flgr1d_data_is_type_##dtype1(datdest)) {               \
00417     flgr1d_copy_##dtype1##_##dtype_src( datdest , datsrc);      \
00418                                     \
00419   }else if(flgr1d_data_is_type_##dtype2(datdest)) {         \
00420     flgr1d_copy_##dtype2##_##dtype_src( datdest , datsrc);      \
00421                                     \
00422   }else if(flgr1d_data_is_type_##dtype3(datdest)) {         \
00423     flgr1d_copy_##dtype3##_##dtype_src( datdest , datsrc);      \
00424                                     \
00425   }else if(flgr1d_data_is_type_##dtype4(datdest)) {         \
00426     flgr1d_copy_##dtype4##_##dtype_src( datdest , datsrc);      \
00427                                     \
00428   }else if(flgr1d_data_is_type_##dtype5(datdest)) {         \
00429     flgr1d_copy_##dtype5##_##dtype_src( datdest , datsrc);      \
00430                                     \
00431   }else if(flgr1d_data_is_type_##dtype6(datdest)) {         \
00432     flgr1d_copy_##dtype6##_##dtype_src( datdest , datsrc);      \
00433                                     \
00434   }else if(flgr1d_data_is_type_##dtype7(datdest)) {         \
00435     flgr1d_copy_##dtype7##_##dtype_src( datdest , datsrc);      \
00436                                     \
00437   }else if(flgr1d_data_is_type_##dtype8(datdest)) {         \
00438     flgr1d_copy_##dtype8##_##dtype_src( datdest , datsrc);      \
00439                                     \
00440   }else if(flgr1d_data_is_type_##dtype9(datdest)) {         \
00441     flgr1d_copy_##dtype9##_##dtype_src( datdest , datsrc);      \
00442                                     \
00443   }else error=1
00444 
00445 
00446 
00448 
00457 
00458 FLGR_Ret flgr1d_copy(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
00459   int error=0;
00460   FLGR_Ret ret;
00461 
00462   
00463 
00464 
00465   if((datdest==NULL) || (datsrc==NULL)) {
00466     POST_ERROR("Null objects!\n");
00467     return FLGR_RET_NULL_OBJECT;
00468   }
00469 
00470   if((ret=flgr1d_is_data_same_length(datdest, datsrc))!=FLGR_RET_OK) {
00471     POST_ERROR("src and dest dat have different length !\n");
00472     return ret;
00473   }
00474 
00475   if(datdest->spp != datdest->spp) {
00476     POST_ERROR("Sample per pixel are different\n");
00477     return ret;
00478   }
00479 
00480   if(datsrc->type==FLGR_UINT8) {
00481     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgUINT8,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00482                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00483 
00484   }else if(datsrc->type==FLGR_UINT16) {
00485     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgUINT16,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00486                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00487 
00488   }else if(datsrc->type==FLGR_UINT32) {
00489     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgUINT32,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00490                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00491 
00492   }else if(datsrc->type==FLGR_INT8) {
00493     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgINT8,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00494                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00495 
00496   }else if(datsrc->type==FLGR_INT16) {
00497     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgINT16,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00498                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00499 
00500   }else if(datsrc->type==FLGR_INT32) {
00501     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgINT32,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00502                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00503 
00504   }else if(datsrc->type==FLGR_FLOAT32) {
00505     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgFLOAT32,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00506                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00507 
00508   }else if(datsrc->type==FLGR_FLOAT64) {
00509     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgFLOAT64,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00510                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00511 
00512   }else if(datsrc->type==FLGR_BIT) {
00513     FLGR_MACRO_COPY1D_SRC_FIX_TYPE(fgBIT,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00514                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00515 
00516   }else {
00517     error=1;
00518   }
00519 
00520   if(error==1) {
00521     POST_ERROR("dest data type unknown!\n");
00522     return FLGR_RET_TYPE_UNKNOWN;
00523   }
00524 
00525   return FLGR_RET_OK;
00526 
00527 }
00528 
00529 
00530 
00531 
00532 
00533 
00534 
00535 
00536 
00537 
00538 
00539 
00540 
00541 
00542 
00543 
00544 
00545 
00546 #define FLGR_MACRO_COPY2D(dtypeDest, dtypeSrc)          \
00547   int i;                            \
00548   FLGR_Data1D **dest = datdest->row;                \
00549   FLGR_Data1D **src = datsrc->row;              \
00550                                 \
00551                     \
00552                                 \
00553   for(i=0;i<datsrc->size_y;i++) {               \
00554     flgr1d_copy_##dtypeDest##_##dtypeSrc(dest[i],src[i]);   \
00555   }                             \
00556   return
00557 
00558 
00559 void flgr2d_copy_fgBIT_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00560   FLGR_MACRO_COPY2D(fgBIT,fgBIT);
00561 }
00562 void flgr2d_copy_fgUINT8_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00563   FLGR_MACRO_COPY2D(fgUINT8,fgBIT);
00564 }
00565 void flgr2d_copy_fgUINT16_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00566   FLGR_MACRO_COPY2D(fgUINT16,fgBIT);
00567 }
00568 void flgr2d_copy_fgUINT32_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00569   FLGR_MACRO_COPY2D(fgUINT32,fgBIT);
00570 }
00571 void flgr2d_copy_fgINT8_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00572   FLGR_MACRO_COPY2D(fgINT8,fgBIT);
00573 }
00574 void flgr2d_copy_fgINT16_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00575   FLGR_MACRO_COPY2D(fgINT16,fgBIT);
00576 }
00577 void flgr2d_copy_fgINT32_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00578   FLGR_MACRO_COPY2D(fgINT32,fgBIT);
00579 }
00580 void flgr2d_copy_fgFLOAT32_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00581   FLGR_MACRO_COPY2D(fgFLOAT32,fgBIT);
00582 }
00583 void flgr2d_copy_fgFLOAT64_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00584   FLGR_MACRO_COPY2D(fgFLOAT64,fgBIT);
00585 }
00586 
00587 
00588 
00589 
00590 void flgr2d_copy_fgBIT_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00591   FLGR_MACRO_COPY2D(fgBIT,fgUINT8);
00592 }
00593 void flgr2d_copy_fgUINT8_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00594   FLGR_MACRO_COPY2D(fgUINT8,fgUINT8);
00595 }
00596 void flgr2d_copy_fgUINT16_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00597   FLGR_MACRO_COPY2D(fgUINT16,fgUINT8);
00598 }
00599 void flgr2d_copy_fgUINT32_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00600   FLGR_MACRO_COPY2D(fgUINT32,fgUINT8);
00601 }
00602 void flgr2d_copy_fgINT8_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00603   FLGR_MACRO_COPY2D(fgINT8,fgUINT8);
00604 }
00605 void flgr2d_copy_fgINT16_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00606   FLGR_MACRO_COPY2D(fgINT16,fgUINT8);
00607 }
00608 void flgr2d_copy_fgINT32_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00609   FLGR_MACRO_COPY2D(fgINT32,fgUINT8);
00610 }
00611 void flgr2d_copy_fgFLOAT32_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00612   FLGR_MACRO_COPY2D(fgFLOAT32,fgUINT8);
00613 }
00614 void flgr2d_copy_fgFLOAT64_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00615   FLGR_MACRO_COPY2D(fgFLOAT64,fgUINT8);
00616 }
00617 
00618 
00619 
00620 
00621 void flgr2d_copy_fgBIT_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00622   FLGR_MACRO_COPY2D(fgBIT,fgUINT16);
00623 }
00624 void flgr2d_copy_fgUINT8_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00625   FLGR_MACRO_COPY2D(fgUINT8,fgUINT16);
00626 }
00627 void flgr2d_copy_fgUINT16_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00628   FLGR_MACRO_COPY2D(fgUINT16,fgUINT16);
00629 }
00630 void flgr2d_copy_fgUINT32_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00631   FLGR_MACRO_COPY2D(fgUINT32,fgUINT16);
00632 }
00633 void flgr2d_copy_fgINT8_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00634   FLGR_MACRO_COPY2D(fgINT8,fgUINT16);
00635 }
00636 void flgr2d_copy_fgINT16_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00637   FLGR_MACRO_COPY2D(fgINT16,fgUINT16);
00638 }
00639 void flgr2d_copy_fgINT32_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00640   FLGR_MACRO_COPY2D(fgINT32,fgUINT16);
00641 }
00642 void flgr2d_copy_fgFLOAT32_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00643   FLGR_MACRO_COPY2D(fgFLOAT32,fgUINT16);
00644 }
00645 void flgr2d_copy_fgFLOAT64_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00646   FLGR_MACRO_COPY2D(fgFLOAT64,fgUINT16);
00647 }
00648 
00649 
00650 
00651 
00652 
00653 
00654 void flgr2d_copy_fgBIT_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00655   FLGR_MACRO_COPY2D(fgBIT,fgUINT32);
00656 }
00657 void flgr2d_copy_fgUINT8_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00658   FLGR_MACRO_COPY2D(fgUINT8,fgUINT32);
00659 }
00660 void flgr2d_copy_fgUINT16_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00661   FLGR_MACRO_COPY2D(fgUINT16,fgUINT32);
00662 }
00663 void flgr2d_copy_fgUINT32_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00664   FLGR_MACRO_COPY2D(fgUINT32,fgUINT32);
00665 }
00666 void flgr2d_copy_fgINT8_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00667   FLGR_MACRO_COPY2D(fgINT8,fgUINT32);
00668 }
00669 void flgr2d_copy_fgINT16_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00670   FLGR_MACRO_COPY2D(fgINT16,fgUINT32);
00671 }
00672 void flgr2d_copy_fgINT32_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00673   FLGR_MACRO_COPY2D(fgINT32,fgUINT32);
00674 }
00675 void flgr2d_copy_fgFLOAT32_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00676   FLGR_MACRO_COPY2D(fgFLOAT32,fgUINT32);
00677 }
00678 void flgr2d_copy_fgFLOAT64_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00679   FLGR_MACRO_COPY2D(fgFLOAT64,fgUINT32);
00680 }
00681 
00682 
00683 
00684 
00685 
00686 void flgr2d_copy_fgBIT_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00687   FLGR_MACRO_COPY2D(fgBIT,fgINT8);
00688 }
00689 void flgr2d_copy_fgUINT8_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00690   FLGR_MACRO_COPY2D(fgUINT8,fgINT8);
00691 }
00692 void flgr2d_copy_fgUINT16_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00693   FLGR_MACRO_COPY2D(fgUINT16,fgINT8);
00694 }
00695 void flgr2d_copy_fgUINT32_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00696   FLGR_MACRO_COPY2D(fgUINT32,fgINT8);
00697 }
00698 void flgr2d_copy_fgINT8_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00699   FLGR_MACRO_COPY2D(fgINT8,fgINT8);
00700 }
00701 void flgr2d_copy_fgINT16_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00702   FLGR_MACRO_COPY2D(fgINT16,fgINT8);
00703 }
00704 void flgr2d_copy_fgINT32_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00705   FLGR_MACRO_COPY2D(fgINT32,fgINT8);
00706 }
00707 void flgr2d_copy_fgFLOAT32_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00708   FLGR_MACRO_COPY2D(fgFLOAT32,fgINT8);
00709 }
00710 void flgr2d_copy_fgFLOAT64_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00711   FLGR_MACRO_COPY2D(fgFLOAT64,fgINT8);
00712 }
00713 
00714 
00715 
00716 
00717 void flgr2d_copy_fgBIT_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00718   FLGR_MACRO_COPY2D(fgBIT,fgINT16);
00719 }
00720 void flgr2d_copy_fgUINT8_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00721   FLGR_MACRO_COPY2D(fgUINT8,fgINT16);
00722 }
00723 void flgr2d_copy_fgUINT16_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00724   FLGR_MACRO_COPY2D(fgUINT16,fgINT16);
00725 }
00726 void flgr2d_copy_fgUINT32_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00727   FLGR_MACRO_COPY2D(fgUINT32,fgINT16);
00728 }
00729 void flgr2d_copy_fgINT8_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00730   FLGR_MACRO_COPY2D(fgINT8,fgINT16);
00731 }
00732 void flgr2d_copy_fgINT16_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00733   FLGR_MACRO_COPY2D(fgINT16,fgINT16);
00734 }
00735 void flgr2d_copy_fgINT32_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00736   FLGR_MACRO_COPY2D(fgINT32,fgINT16);
00737 }
00738 void flgr2d_copy_fgFLOAT32_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00739   FLGR_MACRO_COPY2D(fgFLOAT32,fgINT16);
00740 }
00741 void flgr2d_copy_fgFLOAT64_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00742   FLGR_MACRO_COPY2D(fgFLOAT64,fgINT16);
00743 }
00744 
00745 
00746 
00747 
00748 
00749 
00750 void flgr2d_copy_fgBIT_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00751   FLGR_MACRO_COPY2D(fgBIT,fgINT32);
00752 }
00753 void flgr2d_copy_fgUINT8_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00754   FLGR_MACRO_COPY2D(fgUINT8,fgINT32);
00755 }
00756 void flgr2d_copy_fgUINT16_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00757   FLGR_MACRO_COPY2D(fgUINT16,fgINT32);
00758 }
00759 void flgr2d_copy_fgUINT32_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00760   FLGR_MACRO_COPY2D(fgUINT32,fgINT32);
00761 }
00762 void flgr2d_copy_fgINT8_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00763   FLGR_MACRO_COPY2D(fgINT8,fgINT32);
00764 }
00765 void flgr2d_copy_fgINT16_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00766   FLGR_MACRO_COPY2D(fgINT16,fgINT32);
00767 }
00768 void flgr2d_copy_fgINT32_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00769   FLGR_MACRO_COPY2D(fgINT32,fgINT32);
00770 }
00771 void flgr2d_copy_fgFLOAT32_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00772   FLGR_MACRO_COPY2D(fgFLOAT32,fgINT32);
00773 }
00774 void flgr2d_copy_fgFLOAT64_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00775   FLGR_MACRO_COPY2D(fgFLOAT64,fgINT32);
00776 }
00777 
00778 
00779 
00780 
00781 
00782 
00783 
00784 
00785 void flgr2d_copy_fgBIT_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00786   FLGR_MACRO_COPY2D(fgBIT,fgFLOAT32);
00787 }
00788 void flgr2d_copy_fgUINT8_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00789   FLGR_MACRO_COPY2D(fgUINT8,fgFLOAT32);
00790 }
00791 void flgr2d_copy_fgUINT16_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00792   FLGR_MACRO_COPY2D(fgUINT16,fgFLOAT32);
00793 }
00794 void flgr2d_copy_fgUINT32_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00795   FLGR_MACRO_COPY2D(fgUINT32,fgFLOAT32);
00796 }
00797 void flgr2d_copy_fgINT8_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00798   FLGR_MACRO_COPY2D(fgINT8,fgFLOAT32);
00799 }
00800 void flgr2d_copy_fgINT16_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00801   FLGR_MACRO_COPY2D(fgINT16,fgFLOAT32);
00802 }
00803 void flgr2d_copy_fgINT32_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00804   FLGR_MACRO_COPY2D(fgINT32,fgFLOAT32);
00805 }
00806 void flgr2d_copy_fgFLOAT32_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00807   FLGR_MACRO_COPY2D(fgFLOAT32,fgFLOAT32);
00808 }
00809 void flgr2d_copy_fgFLOAT64_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00810   FLGR_MACRO_COPY2D(fgFLOAT64,fgFLOAT32);
00811 }
00812 
00813 
00814 
00815 
00816 void flgr2d_copy_fgBIT_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00817   FLGR_MACRO_COPY2D(fgBIT,fgFLOAT64);
00818 }
00819 void flgr2d_copy_fgUINT8_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00820   FLGR_MACRO_COPY2D(fgUINT8,fgFLOAT64);
00821 }
00822 void flgr2d_copy_fgUINT16_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00823   FLGR_MACRO_COPY2D(fgUINT16,fgFLOAT64);
00824 }
00825 void flgr2d_copy_fgUINT32_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00826   FLGR_MACRO_COPY2D(fgUINT32,fgFLOAT64);
00827 }
00828 void flgr2d_copy_fgINT8_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00829   FLGR_MACRO_COPY2D(fgINT8,fgFLOAT64);
00830 }
00831 void flgr2d_copy_fgINT16_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00832   FLGR_MACRO_COPY2D(fgINT16,fgFLOAT64);
00833 }
00834 void flgr2d_copy_fgINT32_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00835   FLGR_MACRO_COPY2D(fgINT32,fgFLOAT64);
00836 }
00837 void flgr2d_copy_fgFLOAT32_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00838   FLGR_MACRO_COPY2D(fgFLOAT32,fgFLOAT64);
00839 }
00840 void flgr2d_copy_fgFLOAT64_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00841   FLGR_MACRO_COPY2D(fgFLOAT64,fgFLOAT64);
00842 }
00843 
00844 
00845 
00846 
00847 
00849 // Macro for copying considering a fix type for source
00851 #define FLGR_MACRO_COPY2D_SRC_FIX_TYPE(dtype_src,dtype1,dtype2,     \
00852                        dtype3,dtype4,dtype5,dtype6, \
00853                        dtype7,dtype8,dtype9)        \
00854                                     \
00855   if(flgr2d_data_is_type_##dtype1(datdest)) {               \
00856     flgr2d_copy_##dtype1##_##dtype_src( datdest , datsrc);      \
00857                                     \
00858   }else if(flgr2d_data_is_type_##dtype2(datdest)) {         \
00859     flgr2d_copy_##dtype2##_##dtype_src( datdest , datsrc);      \
00860                                     \
00861   }else if(flgr2d_data_is_type_##dtype3(datdest)) {         \
00862     flgr2d_copy_##dtype3##_##dtype_src( datdest , datsrc);      \
00863                                     \
00864   }else if(flgr2d_data_is_type_##dtype4(datdest)) {         \
00865     flgr2d_copy_##dtype4##_##dtype_src( datdest , datsrc);      \
00866                                     \
00867   }else if(flgr2d_data_is_type_##dtype5(datdest)) {         \
00868     flgr2d_copy_##dtype5##_##dtype_src( datdest , datsrc);      \
00869                                     \
00870   }else if(flgr2d_data_is_type_##dtype6(datdest)) {         \
00871     flgr2d_copy_##dtype6##_##dtype_src( datdest , datsrc);      \
00872                                     \
00873   }else if(flgr2d_data_is_type_##dtype7(datdest)) {         \
00874     flgr2d_copy_##dtype7##_##dtype_src( datdest , datsrc);      \
00875                                     \
00876   }else if(flgr2d_data_is_type_##dtype8(datdest)) {         \
00877     flgr2d_copy_##dtype8##_##dtype_src( datdest , datsrc);      \
00878                                     \
00879   }else if(flgr2d_data_is_type_##dtype9(datdest)) {         \
00880     flgr2d_copy_##dtype9##_##dtype_src( datdest , datsrc);      \
00881                                     \
00882   }else error=1
00883 
00885 
00894 
00895 FLGR_Ret flgr2d_copy(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
00896   int error=0;
00897   FLGR_Ret ret;
00898 
00899   
00900 
00901   if((datdest==NULL) || (datsrc==NULL)) {
00902     POST_ERROR("Null objects!\n");
00903     return FLGR_RET_NULL_OBJECT;
00904   }
00905 
00906   if((ret=flgr2d_is_data_same_size(datsrc, datdest))!=FLGR_RET_OK) {
00907     POST_ERROR("src and dest dat have different size !\n");
00908     return ret;
00909   }
00910 
00911   if(datsrc->type==FLGR_UINT8) {
00912     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgUINT8,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00913                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00914 
00915   }else if(datsrc->type==FLGR_UINT16) {
00916     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgUINT16,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00917                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00918 
00919   }else if(datsrc->type==FLGR_UINT32) {
00920     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgUINT32,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00921                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00922 
00923   }else if(datsrc->type==FLGR_INT8) {
00924     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgINT8,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00925                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00926 
00927   }else if(datsrc->type==FLGR_INT16) {
00928     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgINT16,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00929                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00930 
00931   }else if(datsrc->type==FLGR_INT32) {
00932     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgINT32,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00933                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00934 
00935   }else if(datsrc->type==FLGR_FLOAT32) {
00936     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgFLOAT32,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00937                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00938 
00939   }else if(datsrc->type==FLGR_FLOAT64) {
00940     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgFLOAT64,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00941                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00942 
00943   }else if(datsrc->type==FLGR_BIT) {
00944     FLGR_MACRO_COPY2D_SRC_FIX_TYPE(fgBIT,fgBIT,fgUINT8,fgUINT16,fgUINT32,
00945                    fgINT8,fgINT16,fgINT32,fgFLOAT32,fgFLOAT64);
00946 
00947   }else {
00948     error=1;
00949   }
00950 
00951   if(error==1) {
00952     POST_ERROR("dest data type unknown!\n");
00953     return FLGR_RET_TYPE_UNKNOWN;
00954   }
00955 
00956   return FLGR_RET_OK;
00957 
00958 }
00959 
00960 
00961 
00962 
00963 
00964 
00965 
00966 
00967 
00968 void flgr1d_import_raw_fgBIT(FLGR_Data1D *datdest, void* raw) {
00969   FLGR_Data1D datsrc[1];
00970   
00971 
00972   datsrc->bps=datdest->bps;
00973   datsrc->spp=datdest->spp;
00974   datsrc->length=datdest->length;
00975   datsrc->array=(fgBIT*) raw;
00976 
00977   if(raw!=NULL) {
00978     FLGR_MACRO_COPY1D_BIT_DTYPE(fgBIT);
00979   }
00980 }
00981 
00982 void flgr1d_import_raw_fgUINT8(FLGR_Data1D *datdest, void *raw) {
00983   FLGR_Data1D datsrc[1];
00984   
00985 
00986   datsrc->bps=datdest->bps;
00987   datsrc->spp=datdest->spp;
00988   datsrc->length=datdest->length;
00989   datsrc->array=(fgUINT8*)raw;
00990 
00991   if(raw!=NULL) {
00992     FLGR_MACRO_COPY1D_SAME_TYPE;
00993   }
00994 }
00995 
00996 void flgr1d_import_raw_fgUINT16(FLGR_Data1D *datdest, void *raw) {
00997   FLGR_Data1D datsrc[1];
00998   
00999 
01000   datsrc->bps=datdest->bps;
01001   datsrc->spp=datdest->spp;
01002   datsrc->length=datdest->length;
01003   datsrc->array=(fgUINT16*)raw;
01004 
01005   if(raw!=NULL) {
01006     FLGR_MACRO_COPY1D_SAME_TYPE;
01007   }
01008 }
01009 
01010 void flgr1d_import_raw_fgUINT32(FLGR_Data1D *datdest, void *raw) {
01011   FLGR_Data1D datsrc[1];
01012   
01013 
01014   datsrc->bps=datdest->bps;
01015   datsrc->spp=datdest->spp;
01016   datsrc->length=datdest->length;
01017   datsrc->array=(fgUINT32*)raw;
01018 
01019   if(raw!=NULL) {
01020     FLGR_MACRO_COPY1D_SAME_TYPE;
01021   }
01022 }
01023 
01024 void flgr1d_import_raw_fgINT8(FLGR_Data1D *datdest, void *raw) {
01025   FLGR_Data1D datsrc[1];
01026   
01027 
01028   datsrc->bps=datdest->bps;
01029   datsrc->spp=datdest->spp;
01030   datsrc->length=datdest->length;
01031   datsrc->array=(fgINT8*)raw;
01032 
01033   if(raw!=NULL) {
01034     FLGR_MACRO_COPY1D_SAME_TYPE;
01035   }
01036 }
01037 
01038 void flgr1d_import_raw_fgINT16(FLGR_Data1D *datdest, void *raw) {
01039   FLGR_Data1D datsrc[1];
01040   
01041 
01042   datsrc->bps=datdest->bps;
01043   datsrc->spp=datdest->spp;
01044   datsrc->length=datdest->length;
01045   datsrc->array=(fgINT16*)raw;
01046 
01047   if(raw!=NULL) {
01048     FLGR_MACRO_COPY1D_SAME_TYPE;
01049   }
01050 }
01051 
01052 void flgr1d_import_raw_fgINT32(FLGR_Data1D *datdest, void *raw) {
01053   FLGR_Data1D datsrc[1];
01054   
01055 
01056   datsrc->bps=datdest->bps;
01057   datsrc->spp=datdest->spp;
01058   datsrc->length=datdest->length;
01059   datsrc->array=(fgINT32*)raw;
01060 
01061   if(raw!=NULL) {
01062     FLGR_MACRO_COPY1D_SAME_TYPE;
01063   }
01064 }
01065 
01066 void flgr1d_import_raw_fgFLOAT32(FLGR_Data1D *datdest, void *raw) {
01067   FLGR_Data1D datsrc[1];
01068   
01069 
01070   datsrc->bps=datdest->bps;
01071   datsrc->spp=datdest->spp;
01072   datsrc->length=datdest->length;
01073   datsrc->array=(fgFLOAT32*)raw;
01074 
01075   if(raw!=NULL) {
01076     FLGR_MACRO_COPY1D_SAME_TYPE;
01077   }
01078 }
01079 
01080 void flgr1d_import_raw_fgFLOAT64(FLGR_Data1D *datdest, void *raw) {
01081   FLGR_Data1D datsrc[1];
01082   
01083 
01084   datsrc->bps=datdest->bps;
01085   datsrc->spp=datdest->spp;
01086   datsrc->length=datdest->length;
01087   datsrc->array=(fgFLOAT64*)raw;
01088 
01089   if(raw!=NULL) {
01090     FLGR_MACRO_COPY1D_SAME_TYPE;
01091   }
01092 }
01093 
01095 
01103 
01104 FLGR_Ret flgr1d_import_raw_ptr(FLGR_Data1D *datdest, void* raw) {
01105   
01106 
01107   if((datdest==NULL)) {
01108     POST_ERROR("Null objects!\n");
01109     return FLGR_RET_NULL_OBJECT;
01110   }
01111 
01112   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr1d_import_raw,datdest,raw);
01113 }
01114 
01115 
01116 
01117 
01118 
01119 
01120 
01121 
01122 void flgr1d_export_raw_fgBIT(void *raw, FLGR_Data1D *datsrc) {
01123   FLGR_Data1D datdest[1];
01124   
01125 
01126   datdest->bps=datsrc->bps;
01127   datdest->spp=datsrc->spp;
01128   datdest->length=datsrc->length;
01129   datdest->array=(fgBIT*) raw;
01130 
01131   if(raw!=NULL) {
01132     FLGR_MACRO_COPY1D_DTYPE_BIT(fgBIT);
01133   }
01134 }
01135 
01136 void flgr1d_export_raw_fgUINT8(void *raw, FLGR_Data1D *datsrc) {
01137   FLGR_Data1D datdest[1];
01138   
01139 
01140   datdest->bps=datsrc->bps;
01141   datdest->spp=datsrc->spp;
01142   datdest->length=datsrc->length;
01143   datdest->array=(fgUINT8*) raw;
01144 
01145   if(raw!=NULL) {
01146     FLGR_MACRO_COPY1D_SAME_TYPE;
01147   }
01148 }
01149 
01150 void flgr1d_export_raw_fgUINT16(void *raw, FLGR_Data1D *datsrc) {
01151   FLGR_Data1D datdest[1];
01152   
01153 
01154   datdest->bps=datsrc->bps;
01155   datdest->spp=datsrc->spp;
01156   datdest->length=datsrc->length;
01157   datdest->array=(fgUINT16*) raw;
01158 
01159   if(raw!=NULL) {
01160     FLGR_MACRO_COPY1D_SAME_TYPE;
01161   }
01162 }
01163 
01164 void flgr1d_export_raw_fgUINT32(void *raw, FLGR_Data1D *datsrc) {
01165   FLGR_Data1D datdest[1];
01166   
01167 
01168   datdest->bps=datsrc->bps;
01169   datdest->spp=datsrc->spp;
01170   datdest->length=datsrc->length;
01171   datdest->array=(fgUINT32*) raw;
01172 
01173   if(raw!=NULL) {
01174     FLGR_MACRO_COPY1D_SAME_TYPE;
01175   }
01176 }
01177 
01178 void flgr1d_export_raw_fgINT8(void *raw, FLGR_Data1D *datsrc) {
01179   FLGR_Data1D datdest[1];
01180   
01181 
01182   datdest->bps=datsrc->bps;
01183   datdest->spp=datsrc->spp;
01184   datdest->length=datsrc->length;
01185   datdest->array=(fgINT8*) raw;
01186 
01187   if(raw!=NULL) {
01188     FLGR_MACRO_COPY1D_SAME_TYPE;
01189   }
01190 }
01191 
01192 void flgr1d_export_raw_fgINT16(void *raw, FLGR_Data1D *datsrc) {
01193   FLGR_Data1D datdest[1];
01194   
01195 
01196   datdest->bps=datsrc->bps;
01197   datdest->spp=datsrc->spp;
01198   datdest->length=datsrc->length;
01199   datdest->array=(fgINT16*) raw;
01200 
01201   if(raw!=NULL) {
01202     FLGR_MACRO_COPY1D_SAME_TYPE;
01203   }
01204 }
01205 
01206 void flgr1d_export_raw_fgINT32(void *raw, FLGR_Data1D *datsrc) {
01207   FLGR_Data1D datdest[1];
01208   
01209 
01210   datdest->bps=datsrc->bps;
01211   datdest->spp=datsrc->spp;
01212   datdest->length=datsrc->length;
01213   datdest->array=(fgINT32*) raw;
01214 
01215   if(raw!=NULL) {
01216     FLGR_MACRO_COPY1D_SAME_TYPE;
01217   }
01218 }
01219 
01220 void flgr1d_export_raw_fgFLOAT32(void *raw, FLGR_Data1D *datsrc) {
01221   FLGR_Data1D datdest[1];
01222   
01223 
01224   datdest->bps=datsrc->bps;
01225   datdest->spp=datsrc->spp;
01226   datdest->length=datsrc->length;
01227   datdest->array=(fgFLOAT32*) raw;
01228 
01229   if(raw!=NULL) {
01230     FLGR_MACRO_COPY1D_SAME_TYPE;
01231   }
01232 }
01233 
01234 void flgr1d_export_raw_fgFLOAT64(void *raw, FLGR_Data1D *datsrc) {
01235   FLGR_Data1D datdest[1];
01236   
01237 
01238   datdest->bps=datsrc->bps;
01239   datdest->spp=datsrc->spp;
01240   datdest->length=datsrc->length;
01241   datdest->array=(fgFLOAT64*) raw;
01242 
01243   if(raw!=NULL) {
01244     FLGR_MACRO_COPY1D_SAME_TYPE;
01245   }
01246 }
01247 
01249 
01257 
01258 FLGR_Ret flgr1d_export_raw_ptr(void* raw, FLGR_Data1D *datsrc) {
01259   
01260 
01261   if((datsrc==NULL)) {
01262     POST_ERROR("Null objects!\n");
01263     return FLGR_RET_NULL_OBJECT;
01264   }
01265 
01266   FLGR_DISPATCH_PROCEDURE(datsrc->type,flgr1d_export_raw,raw,datsrc);
01267 }
01268 
01269 
01270 
01271 
01272 
01273 
01274 
01275 
01276 
01277 
01278 
01279 
01281 // Macro for different type of set_datafromRaw
01283 #define FLGR_MACRO_IMPORT2D_RAW(dtype)          \
01284   FLGR_Data1D **dest = datdest->row;            \
01285   int spp = datdest->spp;               \
01286   int size = (datdest->size_x*sizeof(dtype)*spp);   \
01287   int i;                        \
01288                             \
01289                 \
01290                             \
01291   for(i=0 ; i < datdest->size_y ; i++) {        \
01292     flgr1d_import_raw_##dtype(dest[i],raw);     \
01293     raw += size;                    \
01294   }                         \
01295   return
01296 
01297 
01298 void flgr2d_import_raw_fgBIT(FLGR_Data2D *datdest, void* raw) {
01299   FLGR_MACRO_IMPORT2D_RAW(fgBIT);
01300 }
01301 void flgr2d_import_raw_fgUINT8(FLGR_Data2D *datdest, void* raw) {
01302   FLGR_MACRO_IMPORT2D_RAW(fgUINT8);
01303 }
01304 void flgr2d_import_raw_fgUINT16(FLGR_Data2D *datdest, void* raw) {
01305   FLGR_MACRO_IMPORT2D_RAW(fgUINT16);
01306 }
01307 void flgr2d_import_raw_fgUINT32(FLGR_Data2D *datdest, void* raw) {
01308   FLGR_MACRO_IMPORT2D_RAW(fgUINT32);
01309 }
01310 void flgr2d_import_raw_fgINT8(FLGR_Data2D *datdest, void* raw) {
01311   FLGR_MACRO_IMPORT2D_RAW(fgINT8);
01312 }
01313 void flgr2d_import_raw_fgINT16(FLGR_Data2D *datdest, void* raw) {
01314   FLGR_MACRO_IMPORT2D_RAW(fgINT16);
01315 }
01316 void flgr2d_import_raw_fgINT32(FLGR_Data2D *datdest, void* raw) {
01317   FLGR_MACRO_IMPORT2D_RAW(fgINT32);
01318 }
01319 void flgr2d_import_raw_fgFLOAT32(FLGR_Data2D *datdest, void* raw) {
01320   FLGR_MACRO_IMPORT2D_RAW(fgFLOAT32);
01321 }
01322 void flgr2d_import_raw_fgFLOAT64(FLGR_Data2D *datdest, void* raw) {
01323   FLGR_MACRO_IMPORT2D_RAW(fgFLOAT64);
01324 }
01325 
01327 
01335 
01336 FLGR_Ret flgr2d_import_raw_ptr(FLGR_Data2D *datdest, void* raw) {
01337   
01338 
01339   if((datdest==NULL)) {
01340     POST_ERROR("Null objects!\n");
01341     return FLGR_RET_NULL_OBJECT;
01342   }
01343 
01344   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_import_raw,datdest,raw);
01345 }
01346 
01347 
01348 
01349 
01350 
01352 // Macro for different type of set_datafromRaw
01354 #define FLGR_MACRO_EXPORT2D_RAW(dtype)          \
01355   FLGR_Data1D **src = datsrc->row;          \
01356   int spp = datsrc->spp;                \
01357   int size = (datsrc->size_x*sizeof(dtype)*spp);    \
01358   int i;                        \
01359                             \
01360                 \
01361                             \
01362   for(i=0 ; i < datsrc->size_y ; i++) {         \
01363     flgr1d_export_raw_##dtype(raw,src[i]);      \
01364     raw += size;                    \
01365   }                         \
01366   return
01367 
01368 
01369 void flgr2d_export_raw_fgBIT(void* raw, FLGR_Data2D *datsrc) {
01370   FLGR_MACRO_EXPORT2D_RAW(fgBIT);
01371 }
01372 void flgr2d_export_raw_fgUINT8(void* raw, FLGR_Data2D *datsrc) {
01373   FLGR_MACRO_EXPORT2D_RAW(fgUINT8);
01374 }
01375 void flgr2d_export_raw_fgUINT16(void* raw, FLGR_Data2D *datsrc) {
01376   FLGR_MACRO_EXPORT2D_RAW(fgUINT16);
01377 }
01378 void flgr2d_export_raw_fgUINT32(void* raw, FLGR_Data2D *datsrc) {
01379   FLGR_MACRO_EXPORT2D_RAW(fgUINT32);
01380 }
01381 void flgr2d_export_raw_fgINT8(void* raw, FLGR_Data2D *datsrc) {
01382   FLGR_MACRO_EXPORT2D_RAW(fgINT8);
01383 }
01384 void flgr2d_export_raw_fgINT16(void* raw, FLGR_Data2D *datsrc) {
01385   FLGR_MACRO_EXPORT2D_RAW(fgINT16);
01386 }
01387 void flgr2d_export_raw_fgINT32(void* raw, FLGR_Data2D *datsrc) {
01388   FLGR_MACRO_EXPORT2D_RAW(fgINT32);
01389 }
01390 void flgr2d_export_raw_fgFLOAT32(void* raw, FLGR_Data2D *datsrc) {
01391   FLGR_MACRO_EXPORT2D_RAW(fgFLOAT32);
01392 }
01393 void flgr2d_export_raw_fgFLOAT64(void* raw, FLGR_Data2D *datsrc) {
01394   FLGR_MACRO_EXPORT2D_RAW(fgFLOAT64);
01395 }
01396 
01398 
01406 
01407 FLGR_Ret flgr2d_export_raw_ptr(void* raw, FLGR_Data2D *datsrc) {
01408   
01409 
01410   if((datsrc==NULL)) {
01411     POST_ERROR("Null objects!\n");
01412     return FLGR_RET_NULL_OBJECT;
01413   }
01414 
01415   FLGR_DISPATCH_PROCEDURE(datsrc->type,flgr2d_export_raw,raw, datsrc);
01416 }
01417 
01418 
01419 
01420 
01421 void flgr2d_copy_to_1d_fgBIT(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01422   int i,j,k,m=0;
01423   fgBIT val;
01424 
01425   
01426 
01427   for(i=0 ; i<datsrc->size_y ; i++) {
01428     for(j=0 ; j<datsrc->size_x ; j++) {
01429       for(k=0 ; k<datsrc->spp ; k++) {
01430     val = flgr_get_array_fgBIT((fgBIT*) datsrc->array[i],j);
01431     flgr_set_array_fgBIT((fgBIT*) datdest->array,m,val);
01432     m++;
01433       }
01434     }
01435   }
01436 }
01437 void flgr2d_copy_to_1d_fgUINT8(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01438   flgr2d_export_raw_fgUINT8(datdest->array,datsrc);
01439 }
01440 void flgr2d_copy_to_1d_fgUINT16(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01441   flgr2d_export_raw_fgUINT16(datdest->array,datsrc);
01442 }
01443 void flgr2d_copy_to_1d_fgUINT32(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01444   flgr2d_export_raw_fgUINT32(datdest->array,datsrc);
01445 }
01446 void flgr2d_copy_to_1d_fgINT8(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01447   flgr2d_export_raw_fgINT8(datdest->array,datsrc);
01448 }
01449 void flgr2d_copy_to_1d_fgINT16(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01450   flgr2d_export_raw_fgINT16(datdest->array,datsrc);
01451 }
01452 void flgr2d_copy_to_1d_fgINT32(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01453   flgr2d_export_raw_fgINT32(datdest->array,datsrc);
01454 }
01455 void flgr2d_copy_to_1d_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01456   flgr2d_export_raw_fgFLOAT32(datdest->array,datsrc);
01457 }
01458 void flgr2d_copy_to_1d_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01459   flgr2d_export_raw_fgFLOAT64(datdest->array,datsrc);
01460 }
01462 
01467 
01468 FLGR_Ret flgr2d_copy_to_1d(FLGR_Data1D *datdest, FLGR_Data2D *datsrc) {
01469   
01470 
01471   if((datsrc==NULL) || (datdest==NULL)) {
01472     POST_ERROR("Null objects!\n");
01473     return FLGR_RET_NULL_OBJECT;
01474   }
01475 
01476   if(datdest->length != (datsrc->size_y*datsrc->size_x)) {
01477     POST_ERROR("data1d too small\n");
01478     return FLGR_RET_SIZE_ERROR;
01479   }
01480 
01481   if(datdest->type != datdest->type) {
01482     POST_ERROR("type are different\n");
01483     return FLGR_RET_TYPE_DIFFERENT;
01484   }
01485 
01486   if(datdest->spp != datdest->spp) {
01487     POST_ERROR("spp are different\n");
01488     return FLGR_RET_VECTOR_SIZE_DIFFERENT;
01489   }
01490 
01491   FLGR_DISPATCH_PROCEDURE(datsrc->type, flgr2d_copy_to_1d, datdest, datsrc);
01492 }
01493 
01494 
01495 
01496 void flgr1d_copy_to_2d_fgBIT(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01497   int i,j,k,m=0;
01498   fgBIT val;
01499 
01500   
01501 
01502   for(i=0 ; i<datdest->size_y ; i++) {
01503     for(j=0 ; j<datdest->size_x ; j++) {
01504       for(k=0 ; k<datdest->spp ; k++) {
01505     val = flgr_get_array_fgBIT((fgBIT*) datsrc->array,j);
01506     flgr_set_array_fgBIT((fgBIT*) datdest->array[i],m,val);
01507     m++;
01508       }
01509     }
01510   }
01511 }
01512 void flgr1d_copy_to_2d_fgUINT8(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01513   flgr2d_import_raw_fgUINT8(datdest,datsrc->array);
01514 }
01515 void flgr1d_copy_to_2d_fgUINT16(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01516   flgr2d_import_raw_fgUINT16(datdest,datsrc->array);
01517 }
01518 void flgr1d_copy_to_2d_fgUINT32(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01519   flgr2d_import_raw_fgUINT32(datdest,datsrc->array);
01520 }
01521 void flgr1d_copy_to_2d_fgINT8(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01522   flgr2d_import_raw_fgINT8(datdest,datsrc->array);
01523 }
01524 void flgr1d_copy_to_2d_fgINT16(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01525   flgr2d_import_raw_fgINT16(datdest,datsrc->array);
01526 }
01527 void flgr1d_copy_to_2d_fgINT32(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01528   flgr2d_import_raw_fgINT32(datdest,datsrc->array);
01529 }
01530 void flgr1d_copy_to_2d_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01531   flgr2d_import_raw_fgFLOAT32(datdest,datsrc->array);
01532 }
01533 void flgr1d_copy_to_2d_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01534   flgr2d_import_raw_fgFLOAT64(datdest,datsrc->array);
01535 }
01537 
01542 
01543 FLGR_Ret flgr1d_copy_to_2d(FLGR_Data2D *datdest, FLGR_Data1D *datsrc) {
01544   
01545 
01546   if((datsrc==NULL) || (datdest==NULL)) {
01547     POST_ERROR("Null objects!\n");
01548     return FLGR_RET_NULL_OBJECT;
01549   }
01550 
01551   if(datsrc->length != (datdest->size_y*datdest->size_x)) {
01552     POST_ERROR("data1d too small\n");
01553     return FLGR_RET_SIZE_ERROR;
01554   }
01555 
01556   if(datdest->type != datdest->type) {
01557     POST_ERROR("type are different\n");
01558     return FLGR_RET_TYPE_DIFFERENT;
01559   }
01560 
01561   if(datdest->spp != datdest->spp) {
01562     POST_ERROR("spp are different\n");
01563     return FLGR_RET_VECTOR_SIZE_DIFFERENT;
01564   }
01565 
01566   FLGR_DISPATCH_PROCEDURE(datsrc->type, flgr1d_copy_to_2d, datdest, datsrc);
01567 }
01568 
01569 
01570 
01571 
01572 
01574 // macro for flgr1d_mirror
01576 #define FLGR_MACRO_MIRROR1D(dtype)          \
01577   FLGR_Vector *vec1;                    \
01578   int i,k;                      \
01579                             \
01580                 \
01581                             \
01582   vec1 = flgr_vector_create(datsrc->spp,datsrc->type);  \
01583                             \
01584   for(i=0,k=datsrc->length-1 ; k >= 0 ; k--,i++) {  \
01585     flgr1d_get_data_vector_##dtype(datsrc,i,vec1);  \
01586     flgr1d_set_data_vector_##dtype(datdest,k,vec1); \
01587   }                         \
01588                             \
01589   flgr_vector_destroy(vec1);                \
01590   return
01591 
01592 void flgr1d_mirror_fgBIT(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01593   FLGR_MACRO_MIRROR1D(fgBIT);
01594 }
01595 void flgr1d_mirror_fgUINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01596   FLGR_MACRO_MIRROR1D(fgUINT8);
01597 }
01598 void flgr1d_mirror_fgUINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01599   FLGR_MACRO_MIRROR1D(fgUINT16);
01600 }
01601 void flgr1d_mirror_fgUINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01602   FLGR_MACRO_MIRROR1D(fgUINT32);
01603 }
01604 void flgr1d_mirror_fgINT8(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01605   FLGR_MACRO_MIRROR1D(fgINT8);
01606 }
01607 void flgr1d_mirror_fgINT16(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01608   FLGR_MACRO_MIRROR1D(fgINT16);
01609 }
01610 void flgr1d_mirror_fgINT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01611   FLGR_MACRO_MIRROR1D(fgINT32);
01612 }
01613 void flgr1d_mirror_fgFLOAT32(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01614   FLGR_MACRO_MIRROR1D(fgFLOAT32);
01615 }
01616 void flgr1d_mirror_fgFLOAT64(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01617   FLGR_MACRO_MIRROR1D(fgFLOAT64);
01618 }
01620 
01625 
01626 FLGR_Ret flgr1d_mirror(FLGR_Data1D *datdest, FLGR_Data1D *datsrc) {
01627   FLGR_Ret ret;
01628 
01629   
01630 
01631   if((datdest == NULL) || (datsrc == NULL)) {
01632     POST_ERROR("Null objects\n");
01633     return FLGR_RET_NULL_OBJECT;
01634   }
01635 
01636   ret = flgr1d_is_data_same_attributes(datdest, datsrc, __FUNCTION__);
01637   if(ret != FLGR_RET_OK) return ret;
01638   
01639 
01640   FLGR_DISPATCH_PROCEDURE(datdest->type, flgr1d_mirror, datdest, datsrc);
01641 }
01642 
01643 
01644 
01645 
01646 
01647 
01649 // macro for flgr1d_mirror_hmorph
01651 #define FLGR_MACRO_MIRROR1D_HMORPH(dtype)       \
01652   FLGR_Data1D *datdest = flgr1d_create_from(dat);   \
01653                             \
01654                 \
01655                             \
01656   flgr1d_mirror_##dtype(datdest,dat);           \
01657   flgr1d_copy_##dtype##_##dtype(dat,datdest);       \
01658   flgr1d_destroy(datdest);              \
01659                             \
01660   return
01661 
01662 void flgr1d_mirror_hmorph_fgBIT(FLGR_Data1D *dat) {
01663   FLGR_MACRO_MIRROR1D_HMORPH(fgBIT);
01664 }
01665 void flgr1d_mirror_hmorph_fgUINT8(FLGR_Data1D *dat) {
01666   FLGR_MACRO_MIRROR1D_HMORPH(fgUINT8);
01667 }
01668 void flgr1d_mirror_hmorph_fgUINT16(FLGR_Data1D *dat) {
01669   FLGR_MACRO_MIRROR1D_HMORPH(fgUINT16);
01670 }
01671 void flgr1d_mirror_hmorph_fgUINT32(FLGR_Data1D *dat) {
01672   FLGR_MACRO_MIRROR1D_HMORPH(fgUINT32);
01673 }
01674 void flgr1d_mirror_hmorph_fgINT8(FLGR_Data1D *dat) {
01675   FLGR_MACRO_MIRROR1D_HMORPH(fgINT8);
01676 }
01677 void flgr1d_mirror_hmorph_fgINT16(FLGR_Data1D *dat) {
01678   FLGR_MACRO_MIRROR1D_HMORPH(fgINT16);
01679 }
01680 void flgr1d_mirror_hmorph_fgINT32(FLGR_Data1D *dat) {
01681   FLGR_MACRO_MIRROR1D_HMORPH(fgINT32);
01682 }
01683 void flgr1d_mirror_hmorph_fgFLOAT32(FLGR_Data1D *dat) {
01684   FLGR_MACRO_MIRROR1D_HMORPH(fgFLOAT32);
01685 }
01686 void flgr1d_mirror_hmorph_fgFLOAT64(FLGR_Data1D *dat) {
01687   FLGR_MACRO_MIRROR1D_HMORPH(fgFLOAT64);
01688 }
01690 
01694 
01695 FLGR_Ret flgr1d_mirror_hmorph(FLGR_Data1D *dat) {
01696   
01697 
01698   if(dat == NULL) {
01699     POST_ERROR("Null objects\n");
01700     return FLGR_RET_NULL_OBJECT;
01701   }
01702 
01703   FLGR_DISPATCH_PROCEDURE(dat->type, flgr1d_mirror_hmorph, dat);
01704 }
01705 
01706 
01707 
01708 
01709 
01710 
01711 
01712 
01713 
01714 
01715 
01716 
01718 // macro for flgr2d_mirror_horizontal
01720 #define FLGR_MACRO_MIRROR2D_HORIZONTAL(dtype)       \
01721   FLGR_Vector *vec1;                    \
01722   int i,j,k;                        \
01723                             \
01724                 \
01725                             \
01726   vec1 = flgr_vector_create(datsrc->spp,datsrc->type);  \
01727                             \
01728   for(i=0 ; i < datsrc->size_y ; i++) {         \
01729     for(j=0,k=datsrc->size_x-1 ; k >= 0 ; k--,j++) {    \
01730       flgr2d_get_data_vector_##dtype(datsrc,i,j,vec1);  \
01731       flgr2d_set_data_vector_##dtype(datdest,i,k,vec1); \
01732     }                           \
01733   }                         \
01734                             \
01735   flgr_vector_destroy(vec1);                \
01736   return
01737 
01738 void flgr2d_mirror_horizontal_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01739   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgBIT);
01740 }
01741 void flgr2d_mirror_horizontal_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01742   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgUINT8);
01743 }
01744 void flgr2d_mirror_horizontal_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01745   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgUINT16);
01746 }
01747 void flgr2d_mirror_horizontal_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01748   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgUINT32);
01749 }
01750 void flgr2d_mirror_horizontal_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01751   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgINT8);
01752 }
01753 void flgr2d_mirror_horizontal_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01754   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgINT16);
01755 }
01756 void flgr2d_mirror_horizontal_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01757   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgINT32);
01758 }
01759 void flgr2d_mirror_horizontal_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01760   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgFLOAT32);
01761 }
01762 void flgr2d_mirror_horizontal_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01763   FLGR_MACRO_MIRROR2D_HORIZONTAL(fgFLOAT64);
01764 }
01766 
01771 
01772 FLGR_Ret flgr2d_mirror_horizontal(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01773   FLGR_Ret ret;
01774   
01775 
01776 
01777   if((datdest == NULL) || (datsrc == NULL)) {
01778     POST_ERROR("Null objects\n");
01779     return FLGR_RET_NULL_OBJECT;
01780   }
01781 
01782   ret = flgr2d_is_data_same_attributes(datdest, datsrc, __FUNCTION__);
01783   if(ret != FLGR_RET_OK) return ret;
01784   
01785 
01786   FLGR_DISPATCH_PROCEDURE(datdest->type, flgr2d_mirror_horizontal, datdest, datsrc);
01787 }
01788 
01789 
01790 
01791 
01792 
01793 
01794 
01795 
01796 
01797 
01798 
01799 
01801 // macro for flgr2d_mirror_horizontal_hmorph
01803 #define FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(dtype)    \
01804   FLGR_Data2D *datdest = flgr2d_create_from(dat);;  \
01805                             \
01806                 \
01807                             \
01808   flgr2d_mirror_horizontal_##dtype(datdest,dat);    \
01809   flgr2d_copy_##dtype##_##dtype(dat,datdest);       \
01810   flgr2d_destroy(datdest);              \
01811                             \
01812   return
01813 
01814 void flgr2d_mirror_horizontal_hmorph_fgBIT(FLGR_Data2D *dat) {
01815   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgBIT);
01816 }
01817 void flgr2d_mirror_horizontal_hmorph_fgUINT8(FLGR_Data2D *dat) {
01818   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgUINT8);
01819 }
01820 void flgr2d_mirror_horizontal_hmorph_fgUINT16(FLGR_Data2D *dat) {
01821   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgUINT16);
01822 }
01823 void flgr2d_mirror_horizontal_hmorph_fgUINT32(FLGR_Data2D *dat) {
01824   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgUINT32);
01825 }
01826 void flgr2d_mirror_horizontal_hmorph_fgINT8(FLGR_Data2D *dat) {
01827   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgINT8);
01828 }
01829 void flgr2d_mirror_horizontal_hmorph_fgINT16(FLGR_Data2D *dat) {
01830   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgINT16);
01831 }
01832 void flgr2d_mirror_horizontal_hmorph_fgINT32(FLGR_Data2D *dat) {
01833   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgINT32);
01834 }
01835 void flgr2d_mirror_horizontal_hmorph_fgFLOAT32(FLGR_Data2D *dat) {
01836   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgFLOAT32);
01837 }
01838 void flgr2d_mirror_horizontal_hmorph_fgFLOAT64(FLGR_Data2D *dat) {
01839   FLGR_MACRO_MIRROR2D_HORIZONTAL_HMORPH(fgFLOAT64);
01840 }
01842 
01846 
01847 FLGR_Ret flgr2d_mirror_horizontal_hmorph(FLGR_Data2D *dat) {
01848   
01849 
01850   if(dat == NULL) {
01851     POST_ERROR("Null objects\n");
01852     return FLGR_RET_NULL_OBJECT;
01853   }
01854 
01855 
01856   FLGR_DISPATCH_PROCEDURE(dat->type, flgr2d_mirror_horizontal_hmorph, dat);
01857 }
01858 
01859 
01860 
01861 
01862 
01864 
01869 
01870 FLGR_Ret flgr2d_mirror_vertical_hmorph(FLGR_Data2D *dat) {
01871   FLGR_Data1D *row_tmp;
01872   void *tmp;
01873   int i,j;
01874 
01875   
01876 
01877   if(dat==NULL) {
01878     POST_ERROR("Null objects!\n");
01879     return FLGR_RET_NULL_OBJECT;
01880   }
01881 
01882   for(i=0,j=dat->size_y-1; i<dat->size_y/2 ; i++,j--) {
01883     tmp=dat->array[i];
01884     dat->array[i]=dat->array[j];
01885     dat->array[j]=tmp;
01886 
01887     row_tmp = dat->row[i];
01888     dat->row[i] = dat->row[j];
01889     dat->row[j] = row_tmp;
01890 
01891     dat->row[i]->ref2d=i;
01892     dat->row[j]->ref2d=j;
01893 
01894   }
01895 
01896   return FLGR_RET_OK;
01897 }
01898 
01899 
01900 
01902 
01907 
01908 FLGR_Ret flgr2d_mirror_vertical(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01909   FLGR_Ret ret;
01910   
01911 
01912 
01913   if((datdest==NULL) || (datsrc==NULL)) {
01914     POST_ERROR("Null objects!\n");
01915     return FLGR_RET_NULL_OBJECT;
01916   }
01917 
01918   if((ret=flgr2d_copy(datdest,datsrc))!=FLGR_RET_OK) return ret;
01919   return flgr2d_mirror_vertical_hmorph(datdest);
01920 }
01921 
01922 
01923 
01924 
01925 
01926 
01927 
01928 
01929 
01932 #define FLGR_MACRO_FILL_NHB_EVEN_ROWS(dtype)                \
01933   int mid=datsrc->size_y/2;                     \
01934   int h=datsrc->size_y;                         \
01935   int w=datsrc->size_x;                         \
01936   int i,j;                              \
01937   FLGR_Vector *tmp = flgr_vector_create(datsrc->spp,datsrc->type);  \
01938                         \
01939                                     \
01940                                     \
01941   for(i=mid ; i>=0 ; i-=2) {                        \
01942     for(j=0;j<w;j++) {                          \
01943       flgr2d_get_data_vector_##dtype(datsrc,i,j,tmp);           \
01944       flgr2d_set_data_vector_##dtype(datdest,i,j, tmp);         \
01945     }                                   \
01946   }                                 \
01947                                     \
01948   for(i=mid-1 ; i>=0 ; i-=2) {                      \
01949     for(j=0;j<w-1;j++) {                        \
01950       flgr2d_get_data_vector_##dtype(datsrc,i,j,tmp);           \
01951       flgr2d_set_data_vector_##dtype(datdest,i,j+1,tmp);        \
01952     }                                   \
01953     flgr2d_get_data_vector_##dtype(datsrc,i,w-1,tmp);           \
01954     flgr2d_set_data_vector_##dtype(datdest,i,0,tmp);            \
01955   }                                 \
01956                                     \
01957   for(i=mid+1 ; i<h ; i+=2) {                       \
01958     for(j=0;j<w-1;j++) {                        \
01959       flgr2d_get_data_vector_##dtype(datsrc,i,j,tmp);           \
01960       flgr2d_set_data_vector_##dtype(datdest,i,j+1,tmp);        \
01961     }                                   \
01962     flgr2d_get_data_vector_##dtype(datsrc,i,w-1,tmp);           \
01963     flgr2d_set_data_vector_##dtype(datdest,i,0,tmp);            \
01964   }                                 \
01965                                     \
01966   for(i=mid+2 ; i<h ; i+=2) {                       \
01967     for(j=0;j<w;j++) {                          \
01968       flgr2d_get_data_vector_##dtype(datsrc,i,j,tmp);           \
01969       flgr2d_set_data_vector_##dtype(datdest,i,j,tmp);          \
01970     }                                   \
01971   }                                 \
01972                                     \
01973   flgr_vector_destroy(tmp);                     \
01974                                     \
01975   return
01976 
01977 
01978 void flgr2d_fill_nhb_even_rows_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01979   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgBIT);
01980 }
01981 void flgr2d_fill_nhb_even_rows_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01982   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgUINT8);
01983 }
01984 void flgr2d_fill_nhb_even_rows_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01985   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgUINT16);
01986 }
01987 void flgr2d_fill_nhb_even_rows_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01988   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgUINT32);
01989 }
01990 void flgr2d_fill_nhb_even_rows_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01991   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgINT8);
01992 }
01993 void flgr2d_fill_nhb_even_rows_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01994   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgINT16);
01995 }
01996 void flgr2d_fill_nhb_even_rows_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
01997   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgINT32);
01998 }
01999 void flgr2d_fill_nhb_even_rows_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02000   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgFLOAT32);
02001 }
02002 void flgr2d_fill_nhb_even_rows_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02003   FLGR_MACRO_FILL_NHB_EVEN_ROWS(fgFLOAT64);
02004 }
02005 
02007 
02012 
02013 FLGR_Ret flgr2d_fill_nhb_even_rows(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02014   FLGR_Ret ret;
02015 
02016   
02017 
02018   if((datsrc==NULL) || (datdest==NULL)) {
02019     POST_ERROR("Null objects!\n");
02020     return FLGR_RET_NULL_OBJECT;
02021   }
02022 
02023   ret=flgr2d_is_data_same_attributes(datdest,datsrc,__FUNCTION__);
02024   if(ret != FLGR_RET_OK) return ret;
02025 
02026   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_fill_nhb_even_rows,datdest,datsrc);
02027 }
02028 
02029 
02032 #define FLGR_MACRO_FILL_NHB_ODD_ROWS(dtype)             \
02033   int mid=datsrc->size_y/2;                     \
02034   int h=datsrc->size_y;                         \
02035   int w=datsrc->size_x;                         \
02036   int i,j;                              \
02037   FLGR_Vector *tmp = flgr_vector_create(datsrc->spp,datsrc->type);  \
02038                                     \
02039                         \
02040                                     \
02041   for(i=mid ; i>=0 ; i-=2) {                        \
02042     for(j=0;j<w;j++) {                          \
02043       flgr2d_get_data_vector_##dtype(datsrc,i,j,tmp);           \
02044       flgr2d_set_data_vector_##dtype(datdest,i,j, tmp);         \
02045     }                                   \
02046   }                                 \
02047                                     \
02048   for(i=mid-1 ; i>=0 ; i-=2) {                      \
02049     for(j=0;j<w-1;j++) {                        \
02050       flgr2d_get_data_vector_##dtype(datsrc,i,j+1,tmp);         \
02051       flgr2d_set_data_vector_##dtype(datdest,i,j,tmp);          \
02052     }                                   \
02053     flgr2d_get_data_vector_##dtype(datsrc,i,0,tmp);         \
02054     flgr2d_set_data_vector_##dtype(datdest,i,w-1,tmp);          \
02055   }                                 \
02056                                     \
02057   for(i=mid+1 ; i<h ; i+=2) {                       \
02058     for(j=0;j<w-1;j++) {                        \
02059       flgr2d_get_data_vector_##dtype(datsrc,i,j+1,tmp);         \
02060       flgr2d_set_data_vector_##dtype(datdest,i,j,tmp);          \
02061     }                                   \
02062     flgr2d_get_data_vector_##dtype(datsrc,i,0,tmp);         \
02063     flgr2d_set_data_vector_##dtype(datdest,i,w-1,tmp);          \
02064   }                                 \
02065                                     \
02066   for(i=mid+2 ; i<h ; i+=2) {                       \
02067     for(j=0;j<w;j++) {                          \
02068       flgr2d_get_data_vector_##dtype(datsrc,i,j,tmp);           \
02069       flgr2d_set_data_vector_##dtype(datdest,i,j,tmp);          \
02070     }                                   \
02071   }                                 \
02072                                     \
02073   flgr_vector_destroy(tmp);                     \
02074   return
02075 
02076 void flgr2d_fill_nhb_odd_rows_fgBIT(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02077   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgBIT);
02078 }
02079 void flgr2d_fill_nhb_odd_rows_fgUINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02080   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgUINT8);
02081 }
02082 void flgr2d_fill_nhb_odd_rows_fgUINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02083   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgUINT16);
02084 }
02085 void flgr2d_fill_nhb_odd_rows_fgUINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02086   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgUINT32);
02087 }
02088 void flgr2d_fill_nhb_odd_rows_fgINT8(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02089   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgINT8);
02090 }
02091 void flgr2d_fill_nhb_odd_rows_fgINT16(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02092   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgINT16);
02093 }
02094 void flgr2d_fill_nhb_odd_rows_fgINT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02095   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgINT32);
02096 }
02097 void flgr2d_fill_nhb_odd_rows_fgFLOAT32(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02098   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgFLOAT32);
02099 }
02100 void flgr2d_fill_nhb_odd_rows_fgFLOAT64(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02101   FLGR_MACRO_FILL_NHB_ODD_ROWS(fgFLOAT64);
02102 }
02103 
02105 
02110 
02111 FLGR_Ret flgr2d_fill_nhb_odd_rows(FLGR_Data2D *datdest, FLGR_Data2D *datsrc) {
02112   FLGR_Ret ret;
02113 
02114   
02115 
02116   if((datsrc==NULL) || (datdest==NULL)) {
02117     POST_ERROR("Null objects!\n");
02118     return FLGR_RET_NULL_OBJECT;
02119   }
02120 
02121   ret=flgr2d_is_data_same_attributes(datdest,datsrc,__FUNCTION__);
02122   if(ret != FLGR_RET_OK) return ret;
02123 
02124   FLGR_DISPATCH_PROCEDURE(datdest->type,flgr2d_fill_nhb_odd_rows,datdest,datsrc);
02125 }
02126 
02127 
02129 
02139 
02140 FLGR_Ret flgr2d_fill_nhbs_for_6_connexity(FLGR_Data2D *nhbEven, FLGR_Data2D *nhbOdd, FLGR_Data2D *nhb, int SYM) {
02141   FLGR_Ret ret;
02142 
02143   
02144 
02145   if((nhb==NULL) || (nhbOdd==NULL) || (nhbEven==NULL)) {
02146     POST_ERROR("Null objects!\n");
02147     return FLGR_RET_NULL_OBJECT;
02148   }
02149 
02150 
02151   if((ret=flgr2d_is_data_same_attributes(nhbEven,nhbOdd,__FUNCTION__))!=FLGR_RET_OK) {
02152     return ret;
02153   }
02154 
02155   if((ret=flgr2d_is_data_same_attributes(nhbEven,nhb,__FUNCTION__))!=FLGR_RET_OK) {
02156     return ret;
02157   }
02158 
02159   if(SYM==FLGR_NHB_SYM) {
02160     if(flgr2d_data_is_connexity(nhb,FLGR_6_CONNEX)==FLGR_TRUE) {
02161       flgr2d_mirror_horizontal(nhbOdd,nhb);
02162       flgr2d_mirror_vertical_hmorph(nhbOdd);
02163       flgr2d_fill_nhb_even_rows(nhbEven,nhbOdd);
02164     }else {
02165       flgr2d_mirror_horizontal(nhbEven,nhb);
02166       flgr2d_mirror_vertical_hmorph(nhbEven);
02167       flgr2d_copy(nhbOdd,nhbEven);
02168     }
02169   }else {
02170     if(flgr2d_data_is_connexity(nhb,FLGR_6_CONNEX)==FLGR_TRUE) {
02171       flgr2d_copy(nhbEven,nhb);
02172       flgr2d_fill_nhb_odd_rows(nhbOdd,nhbEven);
02173     }else {
02174       flgr2d_copy(nhbEven,nhb);
02175       flgr2d_copy(nhbOdd,nhb);
02176     }
02177   }
02178 
02179   return FLGR_RET_OK;
02180 }
02181 
02182 
02183 
02185