/src/FreeImage/Source/FreeImageToolkit/Rescale.cpp

https://bitbucket.org/cabalistic/ogredeps/ · C++ · 231 lines · 159 code · 25 blank · 47 comment · 53 complexity · 86aab30835691fb04f7a66cbb1f8bab1 MD5 · raw file

  1. // ==========================================================
  2. // Upsampling / downsampling routine
  3. //
  4. // Design and implementation by
  5. // - Hervé Drolon (drolon@infonie.fr)
  6. //
  7. // This file is part of FreeImage 3
  8. //
  9. // COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
  10. // OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
  11. // THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
  12. // OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
  13. // CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
  14. // THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
  15. // SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
  16. // PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
  17. // THIS DISCLAIMER.
  18. //
  19. // Use at your own risk!
  20. // ==========================================================
  21. #include "Resize.h"
  22. FIBITMAP * DLL_CALLCONV
  23. FreeImage_Rescale(FIBITMAP *src, int dst_width, int dst_height, FREE_IMAGE_FILTER filter) {
  24. FIBITMAP *dst = NULL;
  25. if (!FreeImage_HasPixels(src) || (dst_width <= 0) || (dst_height <= 0) || (FreeImage_GetWidth(src) <= 0) || (FreeImage_GetHeight(src) <= 0)) {
  26. return NULL;
  27. }
  28. // select the filter
  29. CGenericFilter *pFilter = NULL;
  30. switch(filter) {
  31. case FILTER_BOX:
  32. pFilter = new(std::nothrow) CBoxFilter();
  33. break;
  34. case FILTER_BICUBIC:
  35. pFilter = new(std::nothrow) CBicubicFilter();
  36. break;
  37. case FILTER_BILINEAR:
  38. pFilter = new(std::nothrow) CBilinearFilter();
  39. break;
  40. case FILTER_BSPLINE:
  41. pFilter = new(std::nothrow) CBSplineFilter();
  42. break;
  43. case FILTER_CATMULLROM:
  44. pFilter = new(std::nothrow) CCatmullRomFilter();
  45. break;
  46. case FILTER_LANCZOS3:
  47. pFilter = new(std::nothrow) CLanczos3Filter();
  48. break;
  49. }
  50. if(!pFilter) {
  51. return NULL;
  52. }
  53. CResizeEngine Engine(pFilter);
  54. // perform upsampling or downsampling
  55. if((FreeImage_GetBPP(src) == 4) || (FreeImage_GetColorType(src) == FIC_PALETTE)) {
  56. // special case for 4-bit images or color map indexed images ...
  57. if(FreeImage_IsTransparent(src) == FALSE) {
  58. FIBITMAP *src24 = NULL;
  59. FIBITMAP *dst24 = NULL;
  60. try {
  61. // transparent conversion to 24-bit (any transparency table will be destroyed)
  62. src24 = FreeImage_ConvertTo24Bits(src);
  63. if(!src24) throw(1);
  64. // perform upsampling or downsampling
  65. dst24 = Engine.scale(src24, dst_width, dst_height);
  66. if(!dst24) throw(1);
  67. FreeImage_Unload(src24); src24 = NULL;
  68. // color quantize to 8-bit
  69. dst = FreeImage_ColorQuantize(dst24, FIQ_NNQUANT);
  70. // free and return
  71. FreeImage_Unload(dst24);
  72. } catch(int) {
  73. if(src24) FreeImage_Unload(src24);
  74. if(dst24) FreeImage_Unload(dst24);
  75. }
  76. } else {
  77. FIBITMAP *src32 = NULL;
  78. try {
  79. // transparent conversion to 32-bit (keep transparency)
  80. src32 = FreeImage_ConvertTo32Bits(src);
  81. if(!src32) throw(1);
  82. // perform upsampling or downsampling
  83. dst = Engine.scale(src32, dst_width, dst_height);
  84. if(!dst) throw(1);
  85. // free and return
  86. FreeImage_Unload(src32);
  87. } catch(int) {
  88. if(src32) FreeImage_Unload(src32);
  89. if(dst) FreeImage_Unload(dst);
  90. }
  91. }
  92. }
  93. else if((FreeImage_GetBPP(src) == 16) && (FreeImage_GetImageType(src) == FIT_BITMAP)) {
  94. // convert 16-bit RGB to 24-bit
  95. FIBITMAP *src24 = NULL;
  96. try {
  97. // transparent conversion to 24-bit (any transparency table will be destroyed)
  98. src24 = FreeImage_ConvertTo24Bits(src);
  99. if(!src24) throw(1);
  100. // perform upsampling or downsampling
  101. dst = Engine.scale(src24, dst_width, dst_height);
  102. if(!dst) throw(1);
  103. // free and return
  104. FreeImage_Unload(src24);
  105. } catch(int) {
  106. if(src24) FreeImage_Unload(src24);
  107. if(dst) FreeImage_Unload(dst);
  108. }
  109. }
  110. else {
  111. // normal case :
  112. // 1- or 8-bit greyscale, 24- or 32-bit RGB(A) images
  113. // 16-bit greyscale, 48- or 64-bit RGB(A) images
  114. // 32-bit float, 96- or 128-bit RGB(A) float images
  115. dst = Engine.scale(src, dst_width, dst_height);
  116. }
  117. delete pFilter;
  118. // copy metadata from src to dst
  119. FreeImage_CloneMetadata(dst, src);
  120. return dst;
  121. }
  122. FIBITMAP * DLL_CALLCONV
  123. FreeImage_MakeThumbnail(FIBITMAP *dib, int max_pixel_size, BOOL convert) {
  124. FIBITMAP *thumbnail = NULL;
  125. int new_width, new_height;
  126. if(!FreeImage_HasPixels(dib) || (max_pixel_size <= 0)) return NULL;
  127. int width = FreeImage_GetWidth(dib);
  128. int height = FreeImage_GetHeight(dib);
  129. if(max_pixel_size == 0) max_pixel_size = 1;
  130. if((width < max_pixel_size) && (height < max_pixel_size)) {
  131. // image is smaller than the requested thumbnail
  132. return FreeImage_Clone(dib);
  133. }
  134. if(width > height) {
  135. new_width = max_pixel_size;
  136. // change image height with the same ratio
  137. double ratio = ((double)new_width / (double)width);
  138. new_height = (int)(height * ratio + 0.5);
  139. if(new_height == 0) new_height = 1;
  140. } else {
  141. new_height = max_pixel_size;
  142. // change image width with the same ratio
  143. double ratio = ((double)new_height / (double)height);
  144. new_width = (int)(width * ratio + 0.5);
  145. if(new_width == 0) new_width = 1;
  146. }
  147. const FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);
  148. // perform downsampling using a bilinear interpolation
  149. switch(image_type) {
  150. case FIT_BITMAP:
  151. case FIT_UINT16:
  152. case FIT_RGB16:
  153. case FIT_RGBA16:
  154. case FIT_FLOAT:
  155. case FIT_RGBF:
  156. case FIT_RGBAF:
  157. {
  158. FREE_IMAGE_FILTER filter = FILTER_BILINEAR;
  159. thumbnail = FreeImage_Rescale(dib, new_width, new_height, filter);
  160. }
  161. break;
  162. case FIT_INT16:
  163. case FIT_UINT32:
  164. case FIT_INT32:
  165. case FIT_DOUBLE:
  166. case FIT_COMPLEX:
  167. default:
  168. // cannot rescale this kind of image
  169. thumbnail = NULL;
  170. break;
  171. }
  172. if((thumbnail != NULL) && (image_type != FIT_BITMAP) && convert) {
  173. // convert to a standard bitmap
  174. FIBITMAP *bitmap = NULL;
  175. switch(image_type) {
  176. case FIT_UINT16:
  177. bitmap = FreeImage_ConvertTo8Bits(thumbnail);
  178. break;
  179. case FIT_RGB16:
  180. bitmap = FreeImage_ConvertTo24Bits(thumbnail);
  181. break;
  182. case FIT_RGBA16:
  183. bitmap = FreeImage_ConvertTo32Bits(thumbnail);
  184. break;
  185. case FIT_FLOAT:
  186. bitmap = FreeImage_ConvertToStandardType(thumbnail, TRUE);
  187. break;
  188. case FIT_RGBF:
  189. bitmap = FreeImage_ToneMapping(thumbnail, FITMO_DRAGO03);
  190. break;
  191. case FIT_RGBAF:
  192. // no way to keep the transparency yet ...
  193. FIBITMAP *rgbf = FreeImage_ConvertToRGBF(thumbnail);
  194. bitmap = FreeImage_ToneMapping(rgbf, FITMO_DRAGO03);
  195. FreeImage_Unload(rgbf);
  196. break;
  197. }
  198. if(bitmap != NULL) {
  199. FreeImage_Unload(thumbnail);
  200. thumbnail = bitmap;
  201. }
  202. }
  203. // copy metadata from src to dst
  204. FreeImage_CloneMetadata(thumbnail, dib);
  205. return thumbnail;
  206. }