lqr/lqr_energy_buffer.c

   1 /* LiquidRescaling Library
   2  * Copyright (C) 2007-2009 Carlo Baldassi (the "Author") <carlobaldassi@gmail.com>.
   3  * All Rights Reserved.
   4  *
   5  * This library implements the algorithm described in the paper
   6  * "Seam Carving for Content-Aware Image Resizing"
   7  * by Shai Avidan and Ariel Shamir
   8  * which can be found at http://www.faculty.idc.ac.il/arik/imret.pdf
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; version 3 dated June, 2007.
  13
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU Lesser General Public License for more details.
  18
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, see <http://www.gnu.org/licenses/>
  21  */
  22
  23 #include <glib.h>
  24 #include <lqr/lqr_all.h>
  25
  26 LqrRetVal
  27 lqr_energy_buffer_fill_std (LqrEnergyBuffer * ebuffer, LqrCarver * r, gint x, gint y)
  28 {
  29   gfloat ** buffer_float;
  30   gint i, j;
  31
  32   buffer_float = (float **) (ebuffer->buffer);
  33
  34   LqrReadFunc read_float;
  35
  36   switch (ebuffer->read_t)
  37     {
  38       case LQR_ER_BRIGHT:
  39         read_float = lqr_carver_read_brightness;
  40         break;
  41       case LQR_ER_LUMA:
  42         read_float = lqr_carver_read_luma;
  43         break;
  44       default:
  45 #ifdef __LQR_DEBUG__
  46         assert(0);
  47 #endif /* __LQR_DEBUG__ */
  48         return LQR_ERROR;
  49     }
  50
  51   for (i = -ebuffer->radius; i <= ebuffer->radius; i++)
  52     {
  53       for (j = -ebuffer->radius; j <= ebuffer->radius; j++)
  54         {
  55           if (x + i < 0 || x + i >= r->w || y + j < 0 || y + j >= r->h)
  56             {
  57               buffer_float[i][j] = 0;
  58             }
  59           else
  60             {
  61               buffer_float[i][j] = read_float (r, x + i, y + j);
  62             }
  63         }
  64     }
  65
  66   return LQR_OK;
  67 }
  68
  69 LqrRetVal
  70 lqr_energy_buffer_fill_rgba (LqrEnergyBuffer * ebuffer, LqrCarver * r, gint x, gint y)
  71 {
  72   /* TODO */
  73   return LQR_OK;
  74 }
  75
  76 LqrRetVal
  77 lqr_energy_buffer_fill_custom (LqrEnergyBuffer * ebuffer, LqrCarver * r, gint x, gint y)
  78 {
  79   /* TODO */
  80   return LQR_OK;
  81 }
  82
  83
  84 LqrRetVal
  85 lqr_energy_buffer_fill (LqrEnergyBuffer * ebuffer, LqrCarver * r, gint x, gint y)
  86 {
  87   CATCH_CANC (r);
  88
  89   switch (ebuffer->read_t)
  90     {
  91       case LQR_ER_BRIGHT:
  92       case LQR_ER_LUMA:
  93         CATCH (lqr_energy_buffer_fill_std(ebuffer, r, x, y));
  94         break;
  95       case LQR_ER_RGBA:
  96         CATCH (lqr_energy_buffer_fill_rgba(ebuffer, r, x, y));
  97         break;
  98       case LQR_ER_CUSTOM:
  99         CATCH (lqr_energy_buffer_fill_custom(ebuffer, r, x, y));
 100         break;
 101       default:
 102         return LQR_ERROR;
 103     }
 104   return LQR_OK;
 105 }
 106
 107
 108 LqrEnergyBuffer *
 109 lqr_energy_buffer_new_std (gint radius, LqrEnergyReaderType read_func_type)
 110 {
 111   LqrEnergyBuffer * out_ebuffer;
 112   gfloat ** out_buffer_float;
 113   gfloat * out_buffer_float_aux;
 114
 115   gint buf_size1, buf_size2;
 116   gint i;
 117
 118   TRY_N_N (out_ebuffer = g_try_new0 (LqrEnergyBuffer, 1));
 119
 120   buf_size1 = (2 * radius + 1);
 121   buf_size2 = buf_size1 * buf_size1;
 122
 123   TRY_N_N (out_buffer_float_aux = g_try_new0 (gfloat, buf_size2));
 124   TRY_N_N (out_buffer_float = g_try_new0 (gfloat *, buf_size1));
 125   for (i = 0; i < buf_size1; i++)
 126     {
 127       out_buffer_float[i] = out_buffer_float_aux + radius;
 128       out_buffer_float_aux += buf_size1;
 129     }
 130   out_buffer_float += radius;
 131
 132   out_ebuffer->buffer = (void**) out_buffer_float;
 133   out_ebuffer->radius = radius;
 134   out_ebuffer->read_t = read_func_type;
 135
 136   return out_ebuffer;
 137 }
 138
 139 LqrEnergyBuffer *
 140 lqr_energy_buffer_new_rgba (gint radius, LqrEnergyReaderType read_func_type)
 141 {
 142   LqrEnergyBuffer * out_ebuffer;
 143
 144   TRY_N_N (out_ebuffer = g_try_new0 (LqrEnergyBuffer, 1));
 145
 146   out_ebuffer->buffer = NULL;
 147   out_ebuffer->radius = radius;
 148   out_ebuffer->read_t = read_func_type;
 149
 150   /* TODO */
 151   return NULL;
 152 }
 153
 154 LqrEnergyBuffer *
 155 lqr_energy_buffer_new_custom (gint radius, LqrEnergyReaderType read_func_type)
 156 {
 157   LqrEnergyBuffer * out_ebuffer;
 158
 159   TRY_N_N (out_ebuffer = g_try_new0 (LqrEnergyBuffer, 1));
 160
 161   out_ebuffer->buffer = NULL;
 162   out_ebuffer->radius = radius;
 163   out_ebuffer->read_t = read_func_type;
 164
 165   /* TODO */
 166   return NULL;
 167 }
 168
 169 LqrEnergyBuffer *
 170 lqr_energy_buffer_new (gint radius, LqrEnergyReaderType read_func_type)
 171 {
 172   switch (read_func_type)
 173     {
 174       case LQR_ER_BRIGHT:
 175       case LQR_ER_LUMA:
 176         return lqr_energy_buffer_new_std(radius, read_func_type);
 177       case LQR_ER_RGBA:
 178         return lqr_energy_buffer_new_rgba(radius, read_func_type);
 179       case LQR_ER_CUSTOM:
 180         return lqr_energy_buffer_new_custom(radius, read_func_type);
 181       default:
 182 #ifdef __LQR_DEBUG__
 183         assert(0);
 184 #endif /* __LQR_DEBUG__ */
 185         return NULL;
 186     }
 187 }
 188
 189 void
 190 lqr_energy_buffer_destroy (LqrEnergyBuffer * ebuffer)
 191 {
 192   gfloat ** buffer_float;
 193
 194   if (ebuffer == NULL)
 195     {
 196       return;
 197     }
 198
 199   if (ebuffer->buffer == NULL)
 200     {
 201       return;
 202     }
 203
 204   switch (ebuffer->read_t)
 205     {
 206       case LQR_ER_BRIGHT:
 207       case LQR_ER_LUMA:
 208         buffer_float = (gfloat **) (ebuffer->buffer);
 209         buffer_float -= ebuffer->radius;
 210         buffer_float[0] -= ebuffer->radius;
 211         g_free(buffer_float[0]);
 212         g_free(buffer_float);
 213         break;
 214       case LQR_ER_RGBA:
 215         buffer_float = (gfloat **) (ebuffer->buffer);
 216         buffer_float -= ebuffer->radius * 4;
 217         buffer_float[0] -= ebuffer->radius * 4;
 218         g_free(buffer_float[0]);
 219         g_free(buffer_float);
 220         break;
 221       case LQR_ER_CUSTOM:
 222         /* TODO */
 223         return;
 224       default:
 225 #ifdef __LQR_DEBUG__
 226         assert(0);
 227 #endif /* __LQR_DEBUG__ */
 228         return;
 229     }
 230 }
 231
 232 LQR_PUBLIC
 233 gfloat
 234 lqr_energy_buffer_read_bright (LqrEnergyBuffer * ebuffer, gint x, gint y)
 235 {
 236   gfloat ** buffer_float;
 237
 238   if (ebuffer == NULL || ebuffer->read_t != LQR_ER_BRIGHT ||
 239       x < -ebuffer->radius || x > ebuffer->radius ||
 240       y < -ebuffer->radius || y > ebuffer->radius)
 241     {
 242       return 0;
 243     }
 244
 245   buffer_float = (gfloat **) (ebuffer->buffer);
 246
 247   return buffer_float[x][y];
 248 }
 249
 250 LQR_PUBLIC
 251 gfloat
 252 lqr_energy_buffer_read_luma (LqrEnergyBuffer * ebuffer, gint x, gint y)
 253 {
 254   gfloat ** buffer_float;
 255
 256   if (ebuffer == NULL || ebuffer->read_t != LQR_ER_LUMA ||
 257       x < -ebuffer->radius || x > ebuffer->radius ||
 258       y < -ebuffer->radius || y > ebuffer->radius)
 259     {
 260       return 0;
 261     }
 262
 263
 264   buffer_float = (gfloat **) (ebuffer->buffer);
 265
 266   return buffer_float[x][y];
 267 }
 268
 269 LQR_PUBLIC
 270 gfloat
 271 lqr_energy_buffer_read_rgba (LqrEnergyBuffer * ebuffer, gint x, gint y, gint channel)
 272 {
 273   gfloat ** buffer_float;
 274
 275   if (ebuffer == NULL || ebuffer->read_t != LQR_ER_RGBA ||
 276       x < -ebuffer->radius || x > ebuffer->radius ||
 277       y < -ebuffer->radius || y > ebuffer->radius ||
 278       channel < 0 || channel > 3)
 279     {
 280       return 0;
 281     }
 282
 283   buffer_float = (gfloat **) (ebuffer->buffer);
 284
 285   return buffer_float[x][y] + channel;
 286 }
 287
 288 LQR_PUBLIC
 289 void *
 290 lqr_energy_buffer_read_custom (LqrEnergyBuffer * ebuffer, gint x, gint y, gint channel)
 291 {
 292   /* gfloat ** buffer_float; */
 293
 294   if (ebuffer == NULL || ebuffer->read_t != LQR_ER_CUSTOM ||
 295       x < -ebuffer->radius || x > ebuffer->radius ||
 296       y < -ebuffer->radius || y > ebuffer->radius)
 297     {
 298       return NULL;
 299     }
 300
 301   /* buffer_float = (gfloat **) (ebuffer->buffer); */
 302
 303   /* return ebuffer->buffer[x][y] + channel; */
 304   /* TODO */
 305   return NULL;
 306 }
 307
 308 LQR_PUBLIC
 309 LqrEnergyReaderType
 310 lqr_energy_buffer_get_read_t (LqrEnergyBuffer * ebuffer)
 311 {
 312   return ebuffer->read_t;
 313 }
 314
 315 LQR_PUBLIC
 316 gint
 317 lqr_energy_buffer_get_radius (LqrEnergyBuffer * ebuffer)
 318 {
 319   return ebuffer->radius;
 320 }
 321
 322