~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Linux Cross Reference
Tina6/tina-libs/tina/image/imgPrc_sample.c

Version: ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /**********
  2  *
  3  * Copyright (c) 2003, Division of Imaging Science and Biomedical Engineering,
  4  * University of Manchester, UK.  All rights reserved.
  5  * 
  6  * Redistribution and use in source and binary forms, with or without modification, 
  7  * are permitted provided that the following conditions are met:
  8  * 
  9  *   . Redistributions of source code must retain the above copyright notice, 
 10  *     this list of conditions and the following disclaimer.
 11  *    
 12  *   . Redistributions in binary form must reproduce the above copyright notice,
 13  *     this list of conditions and the following disclaimer in the documentation 
 14  *     and/or other materials provided with the distribution.
 15  * 
 16  *   . Neither the name of the University of Manchester nor the names of its
 17  *     contributors may be used to endorse or promote products derived from this 
 18  *     software without specific prior written permission.
 19  * 
 20  * 
 21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
 25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 31  * POSSIBILITY OF SUCH DAMAGE.
 32  *
 33  **********
 34  *
 35  * Program :    TINA
 36  * File    :  $Source: /home/tina/cvs/tina-libs/tina/image/imgPrc_sample.c,v $
 37  * Date    :  $Date: 2003/09/22 16:09:02 $
 38  * Version :  $Revision: 1.4 $
 39  * CVS Id  :  $Id: imgPrc_sample.c,v 1.4 2003/09/22 16:09:02 tony Exp $
 40  *
 41  * Author  : Legacy TINA
 42  */
 43 
 44 /** 
 45  *  @file
 46  *  @brief Re-sample an image at given scale, with bi-linear interpolation.
 47  *
 48  */
 49 
 50 #include "imgPrc_sample.h"
 51 
 52 #if HAVE_CONFIG_H
 53 #include <config.h>
 54 #endif
 55 
 56 #include <math.h>
 57 #include <tina/sys/sysDef.h>
 58 #include <tina/sys/sysPro.h>
 59 #include <tina/math/mathDef.h>
 60 #include <tina/math/mathPro.h>
 61 #include <tina/image/img_GenDef.h>
 62 #include <tina/image/img_GenPro.h>
 63 
 64 
 65 
 66 /**
 67  * @brief Up- or downsample an image with quadratic interpolation.
 68  * @param k the resampling factor.
 69  * @param im the image to resample.
 70  * @return Imrect The resampled image.
 71  *
 72  * Notes: the resampled pixel is generated using quadratic interpolation
 73  * of the original image over a 3x3 region.  The returned image is 
 74  * allocated here, and must be freed by the caller.
 75  *
 76 */
 77 Imrect         *imf_sample(double k, Imrect * im)
 78 {
 79         Imrect         *im2;
 80         int             width, height;
 81         Imregion       *region;
 82         int             lx, ux, ly, uy;
 83         int             x, y;
 84 
 85         if (im == NULL) return (NULL);
 86 
 87         region = roi_copy(im->region);
 88         lx = region->lx = (int) (region->lx * k);
 89         ly = region->ly = (int) (region->ly * k);
 90         ux = region->ux = (int) (region->ux * k);
 91         uy = region->uy = (int) (region->uy * k);
 92         width = (int) (k * im->width);
 93         height = (int) (k * im->height);
 94 
 95         im2 = im_alloc(height, width, region, float_v);
 96 
 97         for (x = lx; x < ux; x++)
 98                 for (y = ly; y < uy; y++)
 99                 {
100                         float           pixval;
101 
102                         pixval = (float) im_sub_pixqf(im, (y + 0.5) / k, (x + 0.5) / k);
103                         im_put_pixf(pixval, im2, y, x);
104                 }
105 
106         return (im2);
107 }
108 
109 
110 /**
111  * @brief Halve the size of an image, averagin the pixels.
112  * @param im The image to be resampled.
113  * @return Imrect The resampled image.
114  *
115  * Notes: the returned image is allocated here, and must
116  * be freed by the caller.
117  *
118 */
119 Imrect         *imf_halve(Imrect * im)
120 {
121         Imrect         *im2;
122         int             width, height;
123         Imregion       *roi;
124         int             x, y;
125         double          g1, g2, g3, g4, g;
126 
127         if (im == NULL) return (NULL);
128 
129         roi = roi_copy(im->region);
130         roi->lx = (int) ceil(roi->lx / 2.0);
131         roi->ly = (int) ceil(roi->ly / 2.0);
132         roi->ux = (int) floor(roi->ux / 2.0);
133         roi->uy = (int) floor(roi->uy / 2.0);
134         width = (int) floor(im->width / 2.0);
135         height = (int) floor(im->height / 2.0);
136 
137         im2 = im_alloc(height, width, roi, float_v);
138 
139         for (x = roi->lx; x < roi->ux; x++)
140         {
141                 for (y = roi->ly; y < roi->uy; y++)
142                 {
143                         int             x2 = 2 * x, y2 = 2 * y;
144 
145                         IM_PIX_GET(im, y2, x2, g1);
146                         IM_PIX_GET(im, y2 + 1, x2, g2);
147                         IM_PIX_GET(im, y2, x2 + 1, g3);
148                         IM_PIX_GET(im, y2 + 1, x2 + 1, g4);
149                         g = 0.25 * (g1 + g2 + g3 + g4);
150                         IM_PIX_SET(im2, y, x, g);
151                 }
152         }
153 
154         return (im2);
155 }
156 
157 
158 /**
159  * @brief Downsample an image without averaging.
160  * @param downsample The downsampling factor.
161  * @param im The image to downsample.
162  * @return Imrect The downsampled image.
163  *
164  * Notes: this function was written for the Max Planck 
165  * mouse tool project, to allow the sequence to be 
166  * downsampled during loading.  The returned image is 
167  * allocated here, and must be freed by the caller.
168  *
169 */
170 Imrect *imf_downsample(int downsample, Imrect *im)
171 {
172     Imrect *im2=NULL;
173     Imregion *roi=NULL;
174     int x, y, x2, y2, width, height;
175     double g;
176 
177     if(im==NULL) return NULL;
178 
179     roi = roi_copy(im->region);
180     roi->lx = (int) ceil(roi->lx / downsample);
181     roi->ly = (int) ceil(roi->ly / downsample);
182     roi->ux = (int) floor(roi->ux / downsample);
183     roi->uy = (int) floor(roi->uy / downsample);
184     width = (int) floor(im->width / downsample);
185     height = (int) floor(im->height / downsample);
186 
187     im2 = im_alloc(height, width, roi, im->vtype);
188 
189     for (x = roi->lx; x < roi->ux; x++)
190     {
191         for (y = roi->ly; y < roi->uy; y++)
192         {
193             x2 = downsample * x;
194             y2 = downsample * y;
195 
196             IM_PIX_GET(im, y2, x2, g);
197             IM_PIX_SET(im2, y, x, g);
198         }
199     }
200 
201     return im2;
202 }
203 
204 
205 
206 /**
207  * @brief Downsample an image, averaging the pixel values.
208  * @param downsample The downsampling factor.
209  * @param im The image to be downsampled.
210  * @return Imrect The downsampled image.
211  *
212  * Notes: this function was written for the Max Planck 
213  * mouse tool project, to allow the sequence to be 
214  * downsampled during loading.  The returned image is 
215  * allocated here, and must be freed by the caller.
216  * This function is a generalisation of imf_halve, but
217  * handles all image types and any integer downsampling
218  * factor >1.
219  *
220 */
221 Imrect *imf_downsample_average(int downsample, Imrect *im)
222 {
223     Imrect *im2=NULL;
224     Imregion *roi=NULL;
225     int x, y, x2, y2, width, height, i, j;
226     double g, sum;
227 
228     if(im==NULL) return NULL;
229 
230     roi = roi_copy(im->region);
231     roi->lx = (int) ceil(roi->lx / downsample);
232     roi->ly = (int) ceil(roi->ly / downsample);
233     roi->ux = (int) floor(roi->ux / downsample);
234     roi->uy = (int) floor(roi->uy / downsample);
235     width = (int) floor(im->width / downsample);
236     height = (int) floor(im->height / downsample);
237 
238     im2 = im_alloc(height, width, roi, im->vtype);
239 
240 #pragma omp parallel for private(y, x2, y2, sum, g, i, j)
241     for (x = roi->lx; x < roi->ux; x++)
242     {
243         for (y = roi->ly; y < roi->uy; y++)
244         {
245             x2 = downsample * x;
246             y2 = downsample * y;
247             sum = 0;
248 
249             for(i=0; i<downsample; i++)
250             {
251                 for(j=0; j<downsample; j++)
252                 {
253                     IM_PIX_GET(im, (y2+i), (x2+j), g);
254                     sum += g;
255                 }
256             }
257             g = sum/(downsample*downsample);
258             IM_PIX_SET(im2, y, x, g);
259         }
260     }
261 
262     return im2;
263 }
264 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.