Category

Development Platform
Home > SourceCode/Document > Compress-Decompress algrithms > View Code
ilu_scale.c
Package: devil-1.7.99.tar.gz　[view]
Upload User: wmy0603
Upload Date: 2022-05-02
Package Size: 1808k
Code Size: 8k
Category:

Compress-Decompress algrithms

Development Platform:

Visual C++

ilu_scale.c：Code Content
  1. //-----------------------------------------------------------------------------
  2. //
  3. // ImageLib Utility Sources
  4. // Copyright (C) 2000-2008 by Denton Woods
  5. // Last modified: 12/27/2008
  6. //
  7. // Filename: src-ILU/src/ilu_scale.c
  8. //
  9. // Description: Scales an image.
  10. //
  11. //-----------------------------------------------------------------------------
  14. #include "ilu_internal.h"
  15. #include "ilu_states.h"
  18. ILboolean ILAPIENTRY iluEnlargeImage(ILfloat XDim, ILfloat YDim, ILfloat ZDim)
  19. {
  20. if (XDim <= 0.0f || YDim <= 0.0f || ZDim <= 0.0f) {
  21. ilSetError(ILU_INVALID_PARAM);
  22. return IL_FALSE;
  23. }
  25. iluCurImage = ilGetCurImage();
  26. return iluScale((ILuint)(iluCurImage->Width * XDim), (ILuint)(iluCurImage->Height * YDim),
  27. (ILuint)(iluCurImage->Depth * ZDim));
  28. }
  31. ILimage *iluScale1D_(ILimage *Image, ILimage *Scaled, ILuint Width);
  32. ILimage *iluScale2D_(ILimage *Image, ILimage *Scaled, ILuint Width, ILuint Height);
  33. ILimage *iluScale3D_(ILimage *Image, ILimage *Scaled, ILuint Width, ILuint Height, ILuint Depth);
  36. ILboolean ILAPIENTRY iluScale(ILuint Width, ILuint Height, ILuint Depth)
  37. {
  38. ILimage *Temp;
  39. ILboolean UsePal;
  40. ILenum PalType;
  41. ILenum Origin;
  43. iluCurImage = ilGetCurImage();
  44. if (iluCurImage == NULL) {
  45. ilSetError(ILU_ILLEGAL_OPERATION);
  46. return IL_FALSE;
  47. }
  49. if (iluCurImage->Width == Width && iluCurImage->Height == Height && iluCurImage->Depth == Depth)
  50. return IL_TRUE;
  52. // A parameter of 0 is not valid.  Let's just assume that the user wanted a value of 1 instead.
  53. if (Width == 0)  Width = 1;
  54. if (Height == 0) Height = 1;
  55. if (Depth == 0)  Depth = 1;
  57. if ((iluCurImage->Width<Width) || (iluCurImage->Height<Height)) // only do special scale if there is some zoom?
  58. {
  59. switch (iluFilter)
  60. {
  61. case ILU_SCALE_BOX:
  62. case ILU_SCALE_TRIANGLE:
  63. case ILU_SCALE_BELL:
  64. case ILU_SCALE_BSPLINE:
  65. case ILU_SCALE_LANCZOS3:
  66. case ILU_SCALE_MITCHELL:
  68. iluCurImage = ilGetCurImage();
  69. if (iluCurImage == NULL) {
  70. ilSetError(ILU_ILLEGAL_OPERATION);
  71. return IL_FALSE;
  72. }
  74. // Not supported yet.
  75. if (iluCurImage->Type != IL_UNSIGNED_BYTE ||
  76. iluCurImage->Format == IL_COLOUR_INDEX ||
  77. iluCurImage->Depth > 1) {
  78. ilSetError(ILU_ILLEGAL_OPERATION);
  79. return IL_FALSE;
  80. }
  82. if (iluCurImage->Width > Width) // shrink width first
  83. {
  84. Origin = iluCurImage->Origin;
  85. Temp = iluScale_(iluCurImage, Width, iluCurImage->Height, iluCurImage->Depth);
  86. if (Temp != NULL) {
  87. if (!ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data)) {
  88. ilCloseImage(Temp);
  89. return IL_FALSE;
  90. }
  91. iluCurImage->Origin = Origin;
  92. ilCloseImage(Temp);
  93. }
  94. }
  95. else if (iluCurImage->Height > Height) // shrink height first
  96. {
  97. Origin = iluCurImage->Origin;
  98. Temp = iluScale_(iluCurImage, iluCurImage->Width, Height, iluCurImage->Depth);
  99. if (Temp != NULL) {
  100. if (!ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data)) {
  101. ilCloseImage(Temp);
  102. return IL_FALSE;
  103. }
  104. iluCurImage->Origin = Origin;
  105. ilCloseImage(Temp);
  106. }
  107. }
  109. return (ILboolean)iluScaleAdvanced(Width, Height, iluFilter);
  110. }
  111. }
  114. Origin = iluCurImage->Origin;
  115. UsePal = (iluCurImage->Format == IL_COLOUR_INDEX);
  116. PalType = iluCurImage->Pal.PalType;
  117. Temp = iluScale_(iluCurImage, Width, Height, Depth);
  118. if (Temp != NULL) {
  119. if (!ilTexImage(Temp->Width, Temp->Height, Temp->Depth, Temp->Bpp, Temp->Format, Temp->Type, Temp->Data)) {
  120. ilCloseImage(Temp);
  121. return IL_FALSE;
  122. }
  123. iluCurImage->Origin = Origin;
  124. ilCloseImage(Temp);
  125. if (UsePal) {
  126. if (!ilConvertImage(IL_COLOUR_INDEX, IL_UNSIGNED_BYTE))
  127. return IL_FALSE;
  128. ilConvertPal(PalType);
  129. }
  130. return IL_TRUE;
  131. }
  133. return IL_FALSE;
  134. }
  137. ILAPI ILimage* ILAPIENTRY iluScale_(ILimage *Image, ILuint Width, ILuint Height, ILuint Depth)
  138. {
  139. ILimage *Scaled, *CurImage, *ToScale;
  140. ILenum Format, PalType;
  142. CurImage = ilGetCurImage();
  143. Format = Image->Format;
  144. if (Format == IL_COLOUR_INDEX) {
  145. ilSetCurImage(Image);
  146. PalType = Image->Pal.PalType;
  147. ToScale = iConvertImage(iluCurImage, ilGetPalBaseType(Image->Pal.PalType), iluCurImage->Type);
  148. }
  149. else {
  150. ToScale = Image;
  151. }
  153. // So we don't replicate this 3 times (one in each iluScalexD_() function.
  154. Scaled = (ILimage*)icalloc(1, sizeof(ILimage));
  155. if (ilCopyImageAttr(Scaled, ToScale) == IL_FALSE) {
  156. ilCloseImage(Scaled);
  157. if (ToScale != Image)
  158. ilCloseImage(ToScale);
  159. ilSetCurImage(CurImage);
  160. return NULL;
  161. }
  162. if (ilResizeImage(Scaled, Width, Height, Depth, ToScale->Bpp, ToScale->Bpc) == IL_FALSE) {
  163. ilCloseImage(Scaled);
  164. if (ToScale != Image)
  165. ilCloseImage(ToScale);
  166. ilSetCurImage(CurImage);
  167. return NULL;
  168. }
  170. if (Height <= 1 && Image->Height <= 1) {
  171. iluScale1D_(ToScale, Scaled, Width);
  172. }
  173. if (Depth <= 1 && Image->Depth <= 1) {
  174. iluScale2D_(ToScale, Scaled, Width, Height);
  175. }
  176. else {
  177. iluScale3D_(ToScale, Scaled, Width, Height, Depth);
  178. }
  180. if (Format == IL_COLOUR_INDEX) {
  181. //ilSetCurImage(Scaled);
  182. //ilConvertImage(IL_COLOUR_INDEX);
  183. ilSetCurImage(CurImage);
  184. ilCloseImage(ToScale);
  185. }
  187. return Scaled;
  188. }
  191. ILimage *iluScale1D_(ILimage *Image, ILimage *Scaled, ILuint Width)
  192. {
  193. ILuint x1, x2;
  194. ILuint NewX1, NewX2, NewX3, x, c;
  195. ILdouble ScaleX, t1, t2, f;
  196. ILushort *ShortPtr, *SShortPtr;
  197. ILuint *IntPtr, *SIntPtr;
  199. if (Image == NULL) {
  200. ilSetError(ILU_ILLEGAL_OPERATION);
  201. return IL_FALSE;
  202. }
  204. ScaleX = (ILdouble)Width / Image->Width;
  206. ShortPtr = (ILushort*)Image->Data;
  207. SShortPtr = (ILushort*)Scaled->Data;
  208. IntPtr = (ILuint*)Image->Data;
  209. SIntPtr = (ILuint*)Scaled->Data;
  211. if (iluFilter == ILU_NEAREST) {
  212. switch (Image->Bpc)
  213. {
  214. case 1:
  215. for (x = 0; x < Width; x++) {
  216. NewX1 = x * Scaled->Bpp;
  217. NewX2 = (ILuint)(x / ScaleX) * Image->Bpp;
  218. for (c = 0; c < Scaled->Bpp; c++) {
  219. Scaled->Data[NewX1 + c] = Image->Data[NewX2 + c];
  220. }
  221. }
  222. break;
  223. case 2:
  224. for (x = 0; x < Width; x++) {
  225. NewX1 = x * Scaled->Bpp;
  226. NewX2 = (ILuint)(x / ScaleX) * Image->Bpp;
  227. for (c = 0; c < Scaled->Bpp; c++) {
  228. SShortPtr[NewX1 + c] = ShortPtr[NewX2 + c];
  229. }
  230. }
  231. break;
  232. case 4:
  233. for (x = 0; x < Width; x++) {
  234. NewX1 = x * Scaled->Bpp;
  235. NewX2 = (ILuint)(x / ScaleX) * Image->Bpp;
  236. for (c = 0; c < Scaled->Bpp; c++) {
  237. SIntPtr[NewX1 + c] = IntPtr[NewX2 + c];
  238. }
  239. }
  240. break;
  241. }
  242. }
  243. else {  // IL_LINEAR or IL_BILINEAR
  244. switch (Image->Bpc)
  245. {
  246. case 1:
  247. NewX3 = 0;
  248. for (x = 0; x < Width; x++) {
  249. t1 = x / (ILdouble)Width;
  250. t2 = t1 * Width - (ILuint)(t1 * Width);
  251. f = (1.0 - cos(t2 * IL_PI)) * .5;
  252. NewX1 = ((ILuint)(t1 * Width / ScaleX)) * Image->Bpp;
  253. NewX2 = ((ILuint)(t1 * Width / ScaleX) + 1) * Image->Bpp;
  255. for (c = 0; c < Scaled->Bpp; c++) {
  256. x1 = Image->Data[NewX1 + c];
  257. x2 = Image->Data[NewX2 + c];
  259. Scaled->Data[NewX3 + c] = (ILubyte)(x1 * (1.0 - f) + x2 * f);
  260. }
  262. NewX3 += Scaled->Bpp;
  263. }
  264. break;
  265. case 2:
  266. NewX3 = 0;
  267. for (x = 0; x < Width; x++) {
  268. t1 = x / (ILdouble)Width;
  269. t2 = t1 * Width - (ILuint)(t1 * Width);
  270. f = (1.0 - cos(t2 * IL_PI)) * .5;
  271. NewX1 = ((ILuint)(t1 * Width / ScaleX)) * Image->Bpp;
  272. NewX2 = ((ILuint)(t1 * Width / ScaleX) + 1) * Image->Bpp;
  274. for (c = 0; c < Scaled->Bpp; c++) {
  275. x1 = ShortPtr[NewX1 + c];
  276. x2 = ShortPtr[NewX2 + c];
  278. SShortPtr[NewX3 + c] = (ILushort)(x1 * (1.0 - f) + x2 * f);
  279. }
  281. NewX3 += Scaled->Bpp;
  282. }
  283. break;
  284. case 4:
  285. NewX3 = 0;
  286. for (x = 0; x < Width; x++) {
  287. t1 = x / (ILdouble)Width;
  288. t2 = t1 * Width - (ILuint)(t1 * Width);
  289. f = (1.0 - cos(t2 * IL_PI)) * .5;
  290. NewX1 = ((ILuint)(t1 * Width / ScaleX)) * Image->Bpp;
  291. NewX2 = ((ILuint)(t1 * Width / ScaleX) + 1) * Image->Bpp;
  293. for (c = 0; c < Scaled->Bpp; c++) {
  294. x1 = IntPtr[NewX1 + c];
  295. x2 = IntPtr[NewX2 + c];
  297. SIntPtr[NewX3 + c] = (ILuint)(x1 * (1.0 - f) + x2 * f);
  298. }
  300. NewX3 += Scaled->Bpp;
  301. }
  302. break;
  303. }
  304. }
  306. return Scaled;
  307. }