image.c

   1 /*########################################################################
   2 *
   3 *  Copyright(C) 2002-2007. All Rights Reserved.
   4 *
   5 *  Authors: Shivang Patel
   6 *           Jaap de Haan(jdh)
   7 *
   8 *  Changes: jdh -> Added support for ImageMagick that enables
   9 *                  to export files to more than 40 formats.
  10 *   This is free software; you can redistribute it and/or modify it under
  11 *   the terms of the GNU General Public License as published by the Free
  12 *   Software Foundation; either version 2, or (at your option) any later
  13 *   version.
  14 *
  15 *   This is distributed in the hope that it will be useful, but WITHOUT
  16 *   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 *   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 *   for more details.
  19 *
  20 *   You should have received a copy of the GNU General Public License with
  21 *   the fvs source package as the
  22 *   file COPYING. If not, write to the Free Software Foundation, Inc.,
  23 *   59 Temple Place - Suite 330, Boston, MA
  24 *   02111-1307, USA.
  25 ########################################################################*/
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 #include "image.h"
  32
  33 /*!
  34   A fingerprint image structure, a fingerprint image is a 256 gray level
  35   image. This should be enough to do accurate processing. This image
  36   class defines a common format for all algorithms running in this
  37   suite. Images may be imported from different sources such as files,
  38   network data, databases,...
  39 */
  40 typedef struct iFvsImage_t
  41 {
  42     FvsByte_t      *pimg;          /* 8 bit image array */
  43     FvsInt_t        w;             /* width of image */
  44     FvsInt_t        h;             /* height of image */
  45     FvsInt_t        pitch;         /* pitch */
  46     FvsImageFlag_t  flags;         /* flags */
  47     FvsInt_t        dpi;           /* dots per inch */
  48 } iFvsImage_t;
  49
  50
  51 FvsImage_t ImageCreate()
  52 {
  53     iFvsImage_t* p = NULL;
  54
  55     p = (FvsImage_t)malloc(sizeof(iFvsImage_t));
  56     if (p!=NULL)
  57     {
  58         p->h        = 0;
  59         p->w        = 0;
  60         p->pitch    = 0;
  61         p->pimg     = NULL;
  62         p->flags    = FvsImageGray; /* default flag */
  63     }
  64     return (FvsImage_t)p;
  65 }
  66
  67
  68 void ImageDestroy(FvsImage_t image)
  69 {
  70     iFvsImage_t* p = NULL;
  71     if (image==NULL)
  72         return;
  73     (void)ImageSetSize(image, 0, 0);
  74     p = image;
  75     free(p);
  76 }
  77
  78
  79 FvsError_t ImageSetFlag(FvsImage_t img, const FvsImageFlag_t flag)
  80 {
  81     iFvsImage_t* image = (iFvsImage_t*)img;
  82     image->flags = flag;
  83     return FvsOK;
  84 }
  85
  86
  87 FvsError_t ImageSetDPI(FvsImage_t img, const FvsInt_t dpi)
  88 {
  89     iFvsImage_t* image = (iFvsImage_t*)img;
  90     image->dpi = dpi;
  91     return FvsOK;
  92 }
  93
  94
  95 FvsInt_t ImageGetDPI(const FvsImage_t img)
  96 {
  97     iFvsImage_t* image = (iFvsImage_t*)img;
  98     return image->dpi;
  99 }
 100
 101
 102 FvsImageFlag_t ImageGetFlag(const FvsImage_t img)
 103 {
 104     iFvsImage_t* image = (iFvsImage_t*)img;
 105     return image->flags;
 106 }
 107
 108
 109 FvsError_t ImageSetSize(FvsImage_t img, const FvsInt_t width, const FvsInt_t height)
 110 {
 111     iFvsImage_t* image = (iFvsImage_t*)img;
 112     FvsError_t nRet = FvsOK;
 113     FvsInt_t newsize = width*height;
 114
 115     /* special case for zero size */
 116     if (newsize==0)
 117     {
 118         if (image->pimg!=NULL)
 119         {
 120             free(image->pimg);
 121             image->pimg = NULL;
 122             image->w = 0;
 123             image->h = 0;
 124             image->pitch = 0;
 125         }
 126         return FvsOK;
 127     }
 128
 129     if (image->h*image->w != newsize)
 130     {
 131         free(image->pimg);
 132         image->w = 0;
 133         image->h = 0;
 134         image->pitch = 0;
 135         /* This allocates the amount of memory need for the image structure */
 136         image->pimg = (uint8_t*)malloc((size_t)newsize);
 137     }
 138
 139     if (image->pimg == NULL)
 140         nRet = FvsMemory;
 141     else
 142     {
 143         image->h = height;
 144         image->w = width;
 145         image->pitch = width;
 146     }
 147     return nRet;
 148 }
 149
 150
 151 FvsError_t ImageCopy(FvsImage_t destination, const FvsImage_t source)
 152 {
 153     iFvsImage_t* dest = (iFvsImage_t*)destination;
 154     iFvsImage_t* src  = (iFvsImage_t*)source;
 155     FvsError_t nRet = FvsOK;
 156
 157     nRet = ImageSetSize(dest, src->w, src->h);
 158
 159     if (nRet==FvsOK)
 160         memcpy(dest->pimg, src->pimg, (size_t)src->h*src->w);
 161
 162     /* copy the flag */
 163     dest->flags = src->flags;
 164
 165     return nRet;
 166 }
 167
 168
 169 FvsError_t ImageClear(FvsImage_t img)
 170 {
 171     return ImageFlood(img, 0);
 172 }
 173
 174
 175 FvsError_t ImageFlood(FvsImage_t img, const FvsByte_t value)
 176 {
 177     FvsError_t nRet = FvsOK;
 178     iFvsImage_t* image = (iFvsImage_t*)img;
 179     if (image==NULL) return FvsMemory;
 180     if (image->pimg!=NULL)
 181         memset(image->pimg, (int)value, (size_t)(image->h*image->w));
 182     return nRet;
 183 }
 184
 185
 186 /* set a pixel value in the picture */
 187 void ImageSetPixel(FvsImage_t img, const FvsInt_t x, const FvsInt_t y, const FvsByte_t val)
 188 {
 189     iFvsImage_t* image = (iFvsImage_t*)img;
 190     int address = y * image->w + x;
 191     image->pimg[address] = val;
 192 }
 193
 194
 195 /* This function returns the pixel for the x and y value */
 196 FvsByte_t ImageGetPixel(const FvsImage_t img, const FvsInt_t x, const FvsInt_t y)
 197 {
 198     iFvsImage_t* image = (iFvsImage_t*)img;
 199     /* position in array */
 200     int address = y * image->pitch + x;
 201     return image->pimg[address];
 202 }
 203
 204
 205 /* returns a pointer to the image buffer */
 206 FvsByte_t* ImageGetBuffer(FvsImage_t img)
 207 {
 208     iFvsImage_t* image = (iFvsImage_t*)img;
 209     if (image==NULL) return NULL;
 210     return image->pimg;
 211 }
 212
 213
 214 /* retrieve width and height */
 215 FvsInt_t ImageGetWidth(const FvsImage_t img)
 216 {
 217     iFvsImage_t* image = (iFvsImage_t*)img;
 218     if (image==NULL) return -1;
 219     return image->w;
 220 }
 221
 222
 223 FvsInt_t ImageGetHeight(const FvsImage_t img)
 224 {
 225     iFvsImage_t* image = (iFvsImage_t*)img;
 226     if (image==NULL) return -1;
 227     return image->h;
 228 }
 229
 230
 231 FvsInt_t ImageGetSize(const FvsImage_t img)
 232 {
 233     iFvsImage_t* image = (iFvsImage_t*)img;
 234     if (image==NULL) return 0;
 235     return image->h * image->w;
 236 }
 237
 238 /* get the pitch pixel(x,y) pos is at x + y * pitch */
 239 FvsInt_t ImageGetPitch(const FvsImage_t img)
 240 {
 241     iFvsImage_t* image = (iFvsImage_t*)img;
 242     if (image==NULL) return -1;
 243     return image->pitch;
 244 }
 245
 246 FvsBool_t ImageCompareSize(const FvsImage_t image1, const FvsImage_t image2)
 247 {
 248     if (ImageGetWidth(image1)!=ImageGetWidth(image2))
 249         return FvsFalse;
 250     if (ImageGetHeight(image1)!=ImageGetHeight(image2))
 251         return FvsFalse;
 252     return FvsTrue;
 253 }
 254