lqr/lqr_energy.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 <math.h>
  25 #include <lqr/lqr_base.h>
  26 #include <lqr/lqr_gradient.h>
  27 #include <lqr/lqr_rwindow.h>
  28 #include <lqr/lqr_energy.h>
  29 #include <lqr/lqr_progress_pub.h>
  30 #include <lqr/lqr_cursor_pub.h>
  31 #include <lqr/lqr_vmap.h>
  32 #include <lqr/lqr_vmap_list.h>
  33 #include <lqr/lqr_carver_list.h>
  34 #include <lqr/lqr_carver.h>
  35
  36 #ifdef __LQR_DEBUG__
  37 #include <stdio.h>
  38 #include <assert.h>
  39 #endif /* __LQR_DEBUG__ */
  40
  41 /* read normalised pixel value from
  42  * rgb buffer at the given index */
  43 inline gdouble
  44 lqr_pixel_get_norm (void * rgb, gint rgb_ind, LqrColDepth col_depth)
  45 {
  46   switch (col_depth)
  47     {
  48       case LQR_COLDEPTH_8I:
  49         return (gdouble) AS_8I(rgb)[rgb_ind] / 0xFF;
  50       case LQR_COLDEPTH_16I:
  51         return (gdouble) AS_16I(rgb)[rgb_ind] / 0xFFFF;
  52       case LQR_COLDEPTH_32F:
  53         return (gdouble) AS_32F(rgb)[rgb_ind];
  54       case LQR_COLDEPTH_64F:
  55         return (gdouble) AS_64F(rgb)[rgb_ind];
  56       default:
  57 #ifdef __LQR_DEBUG__
  58         assert(0);
  59 #endif /* __LQR_DEBUG__ */
  60         return 0;
  61     }
  62 }
  63
  64 inline gdouble
  65 lqr_pixel_get_rgbcol (void *rgb, gint rgb_ind, LqrColDepth col_depth, LqrImageType image_type, gint channel)
  66 {
  67   gdouble black_fact = 0;
  68
  69   switch (image_type)
  70     {
  71       case LQR_RGB_IMAGE:
  72       case LQR_RGBA_IMAGE:
  73         return lqr_pixel_get_norm (rgb, rgb_ind + channel, col_depth);
  74       case LQR_CMY_IMAGE:
  75         return 1. - lqr_pixel_get_norm (rgb, rgb_ind + channel, col_depth);
  76       case LQR_CMYK_IMAGE:
  77       case LQR_CMYKA_IMAGE:
  78         black_fact = 1 - lqr_pixel_get_norm(rgb, rgb_ind + 3, col_depth);
  79         return black_fact * (1. - (lqr_pixel_get_norm (rgb, rgb_ind + channel, col_depth)));
  80       default:
  81 #ifdef __LQR_DEBUG__
  82         assert(0);
  83 #endif /* __LQR_DEBUG__ */
  84         return 0;
  85     }
  86 }
  87
  88 inline gdouble
  89 lqr_carver_read_brightness_grey (LqrCarver * r, gint x, gint y)
  90 {
  91   gint now = r->raw[y][x];
  92   gint rgb_ind = now * r->channels;
  93   return lqr_pixel_get_norm (r->rgb, rgb_ind, r->col_depth);
  94 }
  95
  96 inline gdouble
  97 lqr_carver_read_brightness_std (LqrCarver * r, gint x, gint y)
  98 {
  99   gdouble red, green, blue;
 100   gint now = r->raw[y][x];
 101   gint rgb_ind = now * r->channels;
 102
 103   red = lqr_pixel_get_rgbcol (r->rgb, rgb_ind, r->col_depth, r->image_type, 0);
 104   green = lqr_pixel_get_rgbcol (r->rgb, rgb_ind, r->col_depth, r->image_type, 1);
 105   blue = lqr_pixel_get_rgbcol (r->rgb, rgb_ind, r->col_depth, r->image_type, 2);
 106   return (red + green + blue) / 3;
 107 }
 108
 109 gdouble
 110 lqr_carver_read_brightness_custom (LqrCarver * r, gint x, gint y)
 111 {
 112   gdouble sum = 0;
 113   gint k;
 114   gchar has_alpha = (r->alpha_channel >= 0 ? 1 : 0);
 115   gchar has_black = (r->black_channel >= 0 ? 1 : 0);
 116   guint col_channels = r->channels - has_alpha - has_black;
 117
 118   gdouble black_fact = 0;
 119
 120   gint now = r->raw[y][x];
 121
 122   if (has_black)
 123     {
 124       black_fact = lqr_pixel_get_norm(r->rgb, now * r->channels + r->black_channel, r->col_depth);
 125     }
 126
 127   for (k = 0; k < r->channels; k++) if ((k != r->alpha_channel) && (k != r->black_channel))
 128     {
 129       gdouble col = lqr_pixel_get_norm(r->rgb, now * r->channels + k, r->col_depth);
 130       sum += 1. - (1. - col) * (1. - black_fact);
 131     }
 132
 133   sum /= col_channels;
 134
 135   if (has_black)
 136     {
 137       sum = 1 - sum;
 138     }
 139
 140   return sum;
 141 }
 142
 143 /* read average pixel value at x, y
 144  * for energy computation */
 145 gdouble
 146 lqr_carver_read_brightness (LqrCarver * r, gint x, gint y)
 147 {
 148   gchar has_alpha = (r->alpha_channel >= 0 ? 1 : 0);
 149   gdouble alpha_fact = 1;
 150
 151   gint now = r->raw[y][x];
 152
 153   gdouble bright = 0;
 154
 155   switch (r->image_type)
 156     {
 157       case LQR_GREY_IMAGE:
 158       case LQR_GREYA_IMAGE:
 159         bright = lqr_carver_read_brightness_grey (r, x, y);
 160         break;
 161       case LQR_RGB_IMAGE:
 162       case LQR_RGBA_IMAGE:
 163       case LQR_CMY_IMAGE:
 164       case LQR_CMYK_IMAGE:
 165       case LQR_CMYKA_IMAGE:
 166         bright = lqr_carver_read_brightness_std (r, x, y);
 167         break;
 168       case LQR_CUSTOM_IMAGE:
 169         bright = lqr_carver_read_brightness_custom (r, x, y);
 170         break;
 171     }
 172
 173   if (has_alpha)
 174     {
 175       alpha_fact = lqr_pixel_get_norm(r->rgb, now * r->channels + r->alpha_channel, r->col_depth);
 176     }
 177
 178   return bright * alpha_fact;
 179 }
 180
 181 inline gdouble
 182 lqr_carver_read_luma_std (LqrCarver * r, gint x, gint y)
 183 {
 184   gdouble red, green, blue;
 185   gint now = r->raw[y][x];
 186   gint rgb_ind = now * r->channels;
 187
 188   red = lqr_pixel_get_rgbcol (r->rgb, rgb_ind, r->col_depth, r->image_type, 0);
 189   green = lqr_pixel_get_rgbcol (r->rgb, rgb_ind, r->col_depth, r->image_type, 1);
 190   blue = lqr_pixel_get_rgbcol (r->rgb, rgb_ind, r->col_depth, r->image_type, 2);
 191   return 0.2126 * red + 0.7152 * green + 0.0722 * blue;
 192 }
 193
 194 gdouble
 195 lqr_carver_read_luma (LqrCarver * r, gint x, gint y)
 196 {
 197   gchar has_alpha = (r->alpha_channel >= 0 ? 1 : 0);
 198   gdouble alpha_fact = 1;
 199
 200   gint now = r->raw[y][x];
 201
 202   gdouble bright = 0;
 203
 204   switch (r->image_type)
 205     {
 206       case LQR_GREY_IMAGE:
 207       case LQR_GREYA_IMAGE:
 208         bright = lqr_carver_read_brightness_grey (r, x, y);
 209         break;
 210       case LQR_RGB_IMAGE:
 211       case LQR_RGBA_IMAGE:
 212       case LQR_CMY_IMAGE:
 213       case LQR_CMYK_IMAGE:
 214       case LQR_CMYKA_IMAGE:
 215         bright = lqr_carver_read_luma_std (r, x, y);
 216         break;
 217       case LQR_CUSTOM_IMAGE:
 218         bright = lqr_carver_read_brightness_custom (r, x, y);
 219         break;
 220     }
 221
 222   if (has_alpha)
 223     {
 224       alpha_fact = lqr_pixel_get_norm(r->rgb, now * r->channels + r->alpha_channel, r->col_depth);
 225     }
 226
 227   return bright * alpha_fact;
 228 }
 229
 230 gdouble
 231 lqr_carver_read_rgba (LqrCarver * r, gint x, gint y, gint channel)
 232 {
 233   gchar has_alpha = (r->alpha_channel >= 0 ? 1 : 0);
 234
 235   gint now = r->raw[y][x];
 236
 237 #ifdef __LQR_DEBUG__
 238   assert(channel >= 0 && channel < 4);
 239 #endif /* __LQR_DEBUG__ */
 240
 241   if (channel < 3)
 242     {
 243       switch (r->image_type)
 244         {
 245           case LQR_GREY_IMAGE:
 246           case LQR_GREYA_IMAGE:
 247             return lqr_carver_read_brightness_grey (r, x, y);
 248           case LQR_RGB_IMAGE:
 249           case LQR_RGBA_IMAGE:
 250           case LQR_CMY_IMAGE:
 251           case LQR_CMYK_IMAGE:
 252           case LQR_CMYKA_IMAGE:
 253             return lqr_pixel_get_rgbcol (r->rgb, now * r->channels, r->col_depth, r->image_type, channel);
 254           case LQR_CUSTOM_IMAGE:
 255           default:
 256 #ifdef __LQR_DEBUG__
 257             assert(0);
 258 #endif /* __LQR_DEBUG__ */
 259             return 0;
 260         }
 261     }
 262   else if (has_alpha)
 263     {
 264       return lqr_pixel_get_norm(r->rgb, now * r->channels + r->alpha_channel, r->col_depth);
 265     }
 266   else
 267     {
 268       return 1;
 269     }
 270 }
 271
 272 gdouble
 273 lqr_carver_read_custom (LqrCarver * r, gint x, gint y, gint channel)
 274 {
 275   gint now = r->raw[y][x];
 276
 277   return lqr_pixel_get_norm(r->rgb, now * r->channels + channel, r->col_depth);
 278 }
 279
 280
 281
 282
 283 #if 0
 284 /* read average pixel value at x, y
 285  * for energy computation */
 286 inline gdouble
 287 lqr_carver_read_brightness (LqrCarver * r, gint x, gint y)
 288 {
 289   gdouble sum = 0;
 290   gint k;
 291   gchar has_alpha = (r->alpha_channel >= 0 ? 1 : 0);
 292   gchar has_black = (r->black_channel >= 0 ? 1 : 0);
 293   guint col_channels = r->channels - has_alpha - has_black;
 294
 295   gdouble alpha_fact = 1;
 296   gdouble black_fact = 0;
 297
 298   gint now = r->raw[y][x];
 299
 300   if (has_alpha)
 301     {
 302       alpha_fact = lqr_pixel_get_norm(r->rgb, now * r->channels + r->alpha_channel, r->col_depth);
 303     }
 304
 305   if (has_black)
 306     {
 307       black_fact = lqr_pixel_get_norm(r->rgb, now * r->channels + r->black_channel, r->col_depth);
 308     }
 309
 310   for (k = 0; k < r->channels; k++) if ((k != r->alpha_channel) && (k != r->black_channel))
 311     {
 312       gdouble col = lqr_pixel_get_norm(r->rgb, now * r->channels + k, r->col_depth);
 313       sum += 1. - (1. - col) * (1. - black_fact);
 314     }
 315
 316   sum /= col_channels;
 317
 318   switch (r->image_type)
 319     {
 320       case LQR_RGB_IMAGE:
 321       case LQR_RGBA_IMAGE:
 322       case LQR_GREY_IMAGE:
 323       case LQR_GREYA_IMAGE:
 324         break;
 325       case LQR_CMY_IMAGE:
 326       case LQR_CMYK_IMAGE:
 327       case LQR_CMYKA_IMAGE:
 328         sum = 1 - sum;
 329         break;
 330       case LQR_CUSTOM_IMAGE:
 331         if (has_black)
 332           {
 333             sum = 1 - sum;
 334           }
 335 #ifdef __LQR_DEBUG__
 336       default:
 337         assert (0);
 338 #endif /* __LQR_DEBUG__ */
 339     }
 340
 341   if (has_alpha)
 342     {
 343       sum *= alpha_fact;
 344     }
 345
 346   return sum;
 347 }
 348 #endif
 349
 350 #if 0
 351 inline gdouble
 352 lqr_carver_read_brightness_abs (LqrCarver * r, gint x1, gint y1, gint x2, gint y2)
 353 {
 354   gchar has_alpha = (r->alpha_channel > 0 ? 1 : 0);
 355   gint p1, p2;
 356   gdouble a1, a2;
 357   gint k;
 358   gdouble sum = 0;
 359   p1 = r->raw[y1][x1];
 360   p2 = r->raw[y2][x2];
 361   if (has_alpha)
 362     {
 363       a1 = R_RGB(r->rgb, p1 * r->channels + r->alpha_channel) / R_RGB_MAX;
 364       a2 = R_RGB(r->rgb, p2 * r->channels + r->alpha_channel) / R_RGB_MAX;
 365     }
 366   else
 367     {
 368       a1 = a2 = 1;
 369     }
 370   for (k = 0; k < r->channels; k++) if (k != r->alpha_channel)
 371     {
 372       sum += fabs(R_RGB(r->rgb, p1 * r->channels + 0) * a1 - R_RGB(r->rgb, p2 * r->channels + 0) * a2);
 373     }
 374   return sum / (R_RGB_MAX * (r->channels - has_alpha));
 375 }
 376
 377 inline gdouble
 378 lqr_carver_read_luma_abs (LqrCarver * r, gint x1, gint y1, gint x2, gint y2)
 379 {
 380   gint p1, p2;
 381   gdouble a1, a2;
 382   p1 = r->raw[y1][x1];
 383   p2 = r->raw[y2][x2];
 384   if (r->image_type == LQR_RGBA_IMAGE)
 385     {
 386       a1 = R_RGB(r->rgb, p1 * r->channels + 3) / R_RGB_MAX;
 387       a2 = R_RGB(r->rgb, p2 * r->channels + 3) / R_RGB_MAX;
 388     }
 389   else
 390     {
 391       a1 = a2 = 1;
 392     }
 393   return (0.2126 * fabs(R_RGB(r->rgb, p1 * r->channels + 0) * a1 - R_RGB(r->rgb, p2 * r->channels + 0) * a2) +
 394           0.7152 * fabs(R_RGB(r->rgb, p1 * r->channels + 1) * a1 - R_RGB(r->rgb, p2 * r->channels + 1) * a2) +
 395           0.0722 * fabs(R_RGB(r->rgb, p1 * r->channels + 2) * a1 - R_RGB(r->rgb, p2 * r->channels + 2) * a2)) /
 396           R_RGB_MAX;
 397 }
 398 #endif
 399
 400 gdouble
 401 lqr_carver_read_cached_std (LqrCarver * r, gint x, gint y)
 402 {
 403   gint z0 = r->raw[y][x];
 404
 405   return r->rcache[z0];
 406 }
 407
 408 gdouble
 409 lqr_carver_read_cached_rgba (LqrCarver * r, gint x, gint y, gint channel)
 410 {
 411   gint z0 = r->raw[y][x];
 412
 413   return r->rcache[z0 * 4 + channel];
 414 }
 415
 416 gdouble
 417 lqr_carver_read_cached_custom (LqrCarver * r, gint x, gint y, gint channel)
 418 {
 419   gint z0 = r->raw[y][x];
 420
 421   return r->rcache[z0 * r->channels + channel];
 422 }
 423
 424 gfloat
 425 lqr_energy_builtin_grad_all (gint x, gint y, gint img_width, gint img_height, LqrReaderWindow * rwindow, LqrGradFunc gf)
 426 {
 427   gdouble gx, gy;
 428
 429   gdouble (*bread_func) (LqrReaderWindow *, gint, gint);
 430
 431   switch (lqr_rwindow_get_read_t(rwindow))
 432     {
 433       case LQR_ER_BRIGHT:
 434         bread_func = lqr_rwindow_read_bright;
 435         break;
 436       case LQR_ER_LUMA:
 437         bread_func = lqr_rwindow_read_luma;
 438         break;
 439       default:
 440 #ifdef __LQR_DEBUG__
 441         assert(0);
 442 #endif /* __LQR_DEBUG__ */
 443         return 0;
 444     }
 445
 446   if (y == 0)
 447     {
 448       gy = bread_func(rwindow, 0, 1) - bread_func(rwindow, 0, 0);
 449     }
 450   else if (y < img_height - 1)
 451     {
 452       gy = (bread_func(rwindow, 0, 1) - bread_func(rwindow, 0, -1)) / 2;
 453     }
 454   else
 455     {
 456       gy = bread_func(rwindow, 0, 0) - bread_func(rwindow, 0, -1);
 457     }
 458
 459   if (x == 0)
 460     {
 461       gx = bread_func(rwindow, 1, 0) - bread_func(rwindow, 0, 0);
 462     }
 463   else if (x < img_width - 1)
 464     {
 465       gx = (bread_func(rwindow, 1, 0) - bread_func(rwindow, -1, 0)) / 2;
 466     }
 467   else
 468     {
 469       gx = bread_func(rwindow, 0, 0) - bread_func(rwindow, -1, 0);
 470     }
 471
 472   return gf(gx, gy);
 473 }
 474
 475 gfloat
 476 lqr_energy_builtin_grad_norm (gint x, gint y, gint img_width, gint img_height, LqrReaderWindow * rwindow, gpointer extra_data)
 477 {
 478   return lqr_energy_builtin_grad_all(x, y, img_width, img_height, rwindow, lqr_grad_norm);
 479 }
 480
 481 gfloat
 482 lqr_energy_builtin_grad_sumabs (gint x, gint y, gint img_width, gint img_height, LqrReaderWindow * rwindow, gpointer extra_data)
 483 {
 484   return lqr_energy_builtin_grad_all(x, y, img_width, img_height, rwindow, lqr_grad_sumabs);
 485 }
 486
 487 gfloat
 488 lqr_energy_builtin_grad_xabs (gint x, gint y, gint img_width, gint img_height, LqrReaderWindow * rwindow, gpointer extra_data)
 489 {
 490   return lqr_energy_builtin_grad_all(x, y, img_width, img_height, rwindow, lqr_grad_xabs);
 491 }
 492
 493 gfloat
 494 lqr_energy_builtin_null (gint x, gint y, gint img_width, gint img_height, LqrReaderWindow * rwindow, gpointer extra_data)
 495 {
 496   return 0;
 497 }
 498
 499
 500 #if 0
 501 /* compute energy at x, y */
 502 gfloat
 503 lqr_energy_abs (LqrCarver * r, gint x, gint y)
 504 {
 505   gdouble gx, gy;
 506
 507   if (y == 0)
 508     {
 509       gy = (*(r->nrg_builtin->rfabs))(r, x, y + 1, x, y);
 510     }
 511   else if (y < r->h - 1)
 512     {
 513       gy = 0.5 * (*(r->nrg_builtin->rfabs))(r, x, y + 1, x, y - 1);
 514     }
 515   else
 516     {
 517       gy = (*(r->nrg_builtin->rfabs))(r, x, y, x, y - 1);
 518     }
 519
 520   if (x == 0)
 521     {
 522       gx = (*(r->nrg_builtin->rfabs))(r, x + 1, y, x, y);
 523     }
 524   else if (x < r->w - 1)
 525     {
 526       gx = 0.5 * (*(r->nrg_builtin->rfabs))(r, x + 1, y, x - 1, y);
 527     }
 528   else
 529     {
 530       gx = (*(r->nrg_builtin->rfabs))(r, x, y, x - 1, y);
 531     }
 532   return (*(r->nrg_builtin->gf))(gx, gy);
 533 }
 534 #endif
 535
 536 /* gradient function for energy computation */
 537 LQR_PUBLIC
 538 LqrRetVal
 539 lqr_carver_set_energy_function_builtin (LqrCarver * r, LqrEnergyFuncBuiltinType ef_ind)
 540 {
 541   switch (ef_ind)
 542     {
 543       case LQR_EF_GRAD_NORM:
 544         CATCH (lqr_carver_set_energy_function (r, lqr_energy_builtin_grad_norm, 1, LQR_ER_BRIGHT, NULL));
 545         break;
 546       case LQR_EF_GRAD_SUMABS:
 547         CATCH (lqr_carver_set_energy_function (r, lqr_energy_builtin_grad_sumabs, 1, LQR_ER_BRIGHT, NULL));
 548         break;
 549       case LQR_EF_GRAD_XABS:
 550         CATCH (lqr_carver_set_energy_function (r, lqr_energy_builtin_grad_xabs, 1, LQR_ER_BRIGHT, NULL));
 551         break;
 552       case LQR_EF_LUMA_GRAD_NORM:
 553         CATCH (lqr_carver_set_energy_function (r, lqr_energy_builtin_grad_norm, 1, LQR_ER_LUMA, NULL));
 554         break;
 555       case LQR_EF_LUMA_GRAD_SUMABS:
 556         CATCH (lqr_carver_set_energy_function (r, lqr_energy_builtin_grad_sumabs, 1, LQR_ER_LUMA, NULL));
 557         break;
 558       case LQR_EF_LUMA_GRAD_XABS:
 559         CATCH (lqr_carver_set_energy_function (r, lqr_energy_builtin_grad_xabs, 1, LQR_ER_LUMA, NULL));
 560         break;
 561       case LQR_EF_NULL:
 562         CATCH (lqr_carver_set_energy_function (r, lqr_energy_builtin_null, 0, LQR_ER_BRIGHT, NULL));
 563         break;
 564       default:
 565         return LQR_ERROR;
 566     }
 567
 568   return LQR_OK;
 569 }
 570
 571 LQR_PUBLIC
 572 LqrRetVal
 573 lqr_carver_set_energy_function (LqrCarver * r, LqrEnergyFunc en_func, gint radius,
 574                 LqrEnergyReaderType reader_type, gpointer extra_data)
 575 {
 576   CATCH_F (r->root == NULL);
 577
 578   r->nrg = en_func;
 579   r->nrg_radius = radius;
 580   r->nrg_read_t = reader_type;
 581   r->nrg_extra_data = extra_data;
 582
 583   lqr_rwindow_destroy (r->rwindow);
 584
 585   if (reader_type == LQR_ER_CUSTOM)
 586     {
 587       CATCH_MEM (r->rwindow = lqr_rwindow_new_custom (radius, r->use_rcache, r->channels));
 588     }
 589   else
 590     {
 591       CATCH_MEM (r->rwindow = lqr_rwindow_new (radius, reader_type, r->use_rcache));
 592     }
 593
 594   return LQR_OK;
 595 }
 596
 597 gdouble *
 598 lqr_carver_generate_rcache_bright (LqrCarver * r)
 599 {
 600   gdouble * buffer;
 601   gint x, y;
 602   gint z0;
 603
 604   TRY_N_N (buffer = g_try_new (gdouble, r->w0 * r->h0));
 605
 606   for (y = 0; y < r->h; y++)
 607     {
 608       for (x = 0; x < r->w; x++)
 609         {
 610           z0 = r->raw[y][x];
 611           buffer[z0] = lqr_carver_read_brightness (r, x, y);
 612         }
 613     }
 614
 615   return buffer;
 616 }
 617
 618 gdouble *
 619 lqr_carver_generate_rcache_luma (LqrCarver * r)
 620 {
 621   gdouble * buffer;
 622   gint x, y;
 623   gint z0;
 624
 625   TRY_N_N (buffer = g_try_new (gdouble, r->w0 * r->h0));
 626
 627   for (y = 0; y < r->h; y++)
 628     {
 629       for (x = 0; x < r->w; x++)
 630         {
 631           z0 = r->raw[y][x];
 632           buffer[z0] = lqr_carver_read_luma (r, x, y);
 633         }
 634     }
 635
 636   return buffer;
 637 }
 638
 639 gdouble *
 640 lqr_carver_generate_rcache_rgba (LqrCarver * r)
 641 {
 642   gdouble * buffer;
 643   gint x, y, k;
 644   gint z0;
 645
 646   TRY_N_N (buffer = g_try_new (gdouble, r->w0 * r->h0 * 4));
 647
 648   for (y = 0; y < r->h; y++)
 649     {
 650       for (x = 0; x < r->w; x++)
 651         {
 652           z0 = r->raw[y][x];
 653           for (k = 0; k < 4; k++)
 654             {
 655               buffer[z0 * 4 + k] = lqr_carver_read_rgba (r, x, y, k);
 656             }
 657         }
 658     }
 659
 660   return buffer;
 661 }
 662
 663 gdouble *
 664 lqr_carver_generate_rcache_custom (LqrCarver * r)
 665 {
 666   gdouble * buffer;
 667   gint x, y, k;
 668   gint z0;
 669
 670   TRY_N_N (buffer = g_try_new (gdouble, r->w0 * r->h0 * r->channels));
 671
 672   for (y = 0; y < r->h; y++)
 673     {
 674       for (x = 0; x < r->w; x++)
 675         {
 676           z0 = r->raw[y][x];
 677           for (k = 0; k < r->channels; k++)
 678             {
 679               buffer[z0 * r->channels + k] = lqr_carver_read_custom (r, x, y, k);
 680             }
 681         }
 682     }
 683
 684   return buffer;
 685 }
 686
 687 gdouble *
 688 lqr_carver_generate_rcache (LqrCarver * r)
 689 {
 690 #ifdef __LQR_DEBUG__
 691   assert (r->w == r->w_start - r->max_level + 1);
 692 #endif /* __LQR_DEBUG__ */
 693
 694   switch (r->nrg_read_t)
 695     {
 696       case LQR_ER_BRIGHT:
 697         return lqr_carver_generate_rcache_bright(r);
 698       case LQR_ER_LUMA:
 699         return lqr_carver_generate_rcache_luma(r);
 700       case LQR_ER_RGBA:
 701         return lqr_carver_generate_rcache_rgba(r);
 702       case LQR_ER_CUSTOM:
 703         return lqr_carver_generate_rcache_custom(r);
 704       default:
 705 #ifdef __LQR_DEBUG__
 706         assert(0);
 707 #endif /* __LQR_DEBUG__ */
 708         return NULL;
 709     }
 710 }
 711
 712 LQR_PUBLIC
 713 LqrCarver *
 714 lqr_energy_preview_new (void * buffer, gint width, gint height, gint channels, LqrColDepth colour_depth)
 715 {
 716   LqrCarver * r;
 717   TRY_N_N (r = lqr_carver_new_ext (buffer, width, height, channels, colour_depth));
 718   lqr_carver_set_preserve_input_image (r);
 719   TRY_E_N (lqr_carver_init_energy_related (r));
 720   lqr_carver_set_use_cache (r, TRUE);
 721   return r;
 722 }
 723
 724 LQR_PUBLIC
 725 gfloat *
 726 lqr_energy_preview_get_energy(LqrCarver * r, gint orientation)
 727 {
 728   gint x, y;
 729   gint z0 = 0;
 730   gint w, h;
 731   gint buf_size;
 732   gint data;
 733   gfloat * nrg_buffer;
 734   gfloat nrg;
 735   gfloat nrg_min = G_MAXFLOAT;
 736   gfloat nrg_max = 0;
 737
 738   TRY_E_N (orientation == 0 || orientation == 1);
 739   TRY_F_N (r->nrg_active);
 740   CATCH_CANC_N (r);
 741
 742   buf_size = r->w * r->h;
 743   TRY_N_N (nrg_buffer = g_try_new (gfloat, buf_size));
 744
 745   if (orientation != lqr_carver_get_orientation(r))
 746     {
 747       TRY_E_N (lqr_carver_transpose(r));
 748     }
 749   TRY_E_N (lqr_carver_build_emap (r));
 750
 751   w = lqr_carver_get_width(r);
 752   h = lqr_carver_get_height(r);
 753
 754   for (y = 0; y < h; y++)
 755     {
 756       for (x = 0; x < w; x++)
 757         {
 758           data = orientation == 0 ? r->raw[y][x] : r->raw[x][y];
 759           nrg = r->en[data];
 760           nrg_max = MAX (nrg_max, nrg);
 761           nrg_min = MIN (nrg_min, nrg);
 762           nrg_buffer[z0++] = r->en[data];
 763         }
 764     }
 765
 766   if (nrg_max > 0)
 767     {
 768       for (z0 = 0; z0 < buf_size; z0++)
 769         {
 770           nrg_buffer[z0] = (nrg_buffer[z0] - nrg_min) / (nrg_max - nrg_min);
 771         }
 772     }
 773
 774   return nrg_buffer;
 775 }
 776