# Đề tài: Image Scale

1. ## Image Scale

Cũng hơi dài nhưng mình đc gần 195 fps lận đó!
Code:
```	//struct Image32
//{
//	int Width,Height;
//	DWORD* pBits;
//};
//DWORD* m_pBits;	// Pixel array
BOOL RlScale(Image32* pSrcImg32)
{
// Scale pSrcImg32 into m_pBits, using RlScale algorithm
if(!m_pBits || !pSrcImg32 || !pSrcImg32->pBits) return 0;
DWORD* Ptr = m_pBits;	// Pointer to dest bits
DWORD* pSrcPtr = pSrcImg32->pBits;	// Pointer to src bits

// KfScale (for all ratio)
float BaseW = float(pSrcImg32->Width)/float(m_Width);
float BaseH = float(pSrcImg32->Height)/float(m_Height);
int StepWl = int(BaseW);
int StepHl = int(BaseH);
int StepSize = 10000;
int StepWr = int((BaseW - StepWl)*StepSize);
int StepHr = int((BaseH - StepHl)*StepSize);
int IncWr = 0;
int IncHr = 0;
int IncH = pSrcImg32->Width*StepHl;
DWORD* pIncPtr = pSrcPtr;
// We can increase speed up to 10% ^_^
if(pSrcImg32->Width < m_Width)	// Scale right
{
if(pSrcImg32->Height < m_Height)	// Scale right and bottom
{
for(int j = 0;j < m_Height;j++)
{
for(int i = 0;i < m_Width;i++)
{
*Ptr++ = *pSrcPtr;
IncWr += StepWr;
if(IncWr >= StepSize)
{
IncWr -= StepSize;
pSrcPtr++;
}
}
IncWr = 0;
IncHr += StepHr;
if(IncHr >= StepSize)
{
IncHr -= StepSize;
pIncPtr += pSrcImg32->Width;
}
pSrcPtr = pIncPtr;
}
}
else if(pSrcImg32->Height == m_Height)	// Only scale right
{
for(int j = 0;j < m_Height;j++)
{
for(int i = 0;i < m_Width;i++)
{
*Ptr++ = *pSrcPtr;
IncWr += StepWr;
if(IncWr >= StepSize)
{
IncWr -= StepSize;
pSrcPtr++;
}
}
IncWr = 0;
pIncPtr += pSrcImg32->Width;
pSrcPtr = pIncPtr;

}
}
else	// Scale right and top
{
for(int j = 0;j < m_Height;j++)
{
for(int i = 0;i < m_Width;i++)
{
*Ptr++ = *pSrcPtr;
IncWr += StepWr;
if(IncWr >= StepSize)
{
IncWr -= StepSize;
pSrcPtr++;
}
}
IncWr = 0;	// Secured
pIncPtr += IncH;
IncHr += StepHr;
if(IncHr >= StepSize)
{
IncHr -= StepSize;
pIncPtr += pSrcImg32->Width;
}
pSrcPtr = pIncPtr;
}
}
}
if(pSrcImg32->Width == m_Width)
{
if(pSrcImg32->Height < m_Height)	// Scale bottom
{
for(int j = 0;j < m_Height;j++)
{
for(int i = 0;i < m_Width;i++) *Ptr++ = *pSrcPtr++;
IncHr += StepHr;
if(IncHr >= StepSize)
{
IncHr -= StepSize;
pIncPtr += pSrcImg32->Width;
}
pSrcPtr = pIncPtr;
}
}
else if(pSrcImg32->Height == m_Height)	// Not scale
{
DWORD* Ptr2 = &m_pBits[m_Width*m_Height];
for(Ptr;Ptr < Ptr2;Ptr++) *Ptr = *pSrcPtr++;
}
else	// Scale top
{
for(int j = 0;j < m_Height;j++)
{
for(int i = 0;i < m_Width;i++) *Ptr++ = *pSrcPtr++;
pIncPtr += IncH;
IncHr += StepHr;
if(IncHr >= StepSize)
{
IncHr -= StepSize;
pIncPtr += pSrcImg32->Width;
}
pSrcPtr = pIncPtr;
}
}
}
else
{
if(pSrcImg32->Height < m_Height)	// Scale left and bottom
{
for(int j = 0;j < m_Height;j++)
{
for(int i = 0;i < m_Width;i++)
{
*Ptr++ = *pSrcPtr;
pSrcPtr += StepWl;
IncWr += StepWr;
if(IncWr >= StepSize)
{
IncWr -= StepSize;
pSrcPtr++;
}
}
IncWr = 0;
IncHr += StepHr;
if(IncHr >= StepSize)
{
IncHr -= StepSize;
pIncPtr += pSrcImg32->Width;
}
pSrcPtr = pIncPtr;
}
}
else if(pSrcImg32->Height == m_Height)	// Only scale left
{
for(int j = 0;j < m_Height;j++)
{
for(int i = 0;i < m_Width;i++)
{
*Ptr++ = *pSrcPtr;
pSrcPtr += StepWl;
IncWr += StepWr;
if(IncWr >= StepSize)
{
IncWr -= StepSize;
pSrcPtr++;
}
}
IncWr = 0;
pIncPtr += pSrcImg32->Width;
pSrcPtr = pIncPtr;
}
}
else	// Scale left and top
{
for(int j = 0;j < m_Height;j++)
{
for(int i = 0;i < m_Width;i++)
{
*Ptr++ = *pSrcPtr;
pSrcPtr += StepWl;
IncWr += StepWr;
if(IncWr >= StepSize)
{
IncWr -= StepSize;
pSrcPtr++;
}
}
IncWr = 0;
pIncPtr += IncH;
IncHr += StepHr;
if(IncHr >= StepSize)
{
IncHr -= StepSize;
pIncPtr += pSrcImg32->Width;
}
pSrcPtr = pIncPtr;
}
}
}
return 1;
}```

2. TQN
Newbie coder
Ngày gia nhập
09 2006
Bài viết
711
Good code !

3. Image Scale là cái gì vậy ???

4. Là thay đổi kích thước hình ảnh đó mà! Ở đây mình viết chủ yếu là dùng cho viết game nên chất lượng hình ảnh vẩn chưa tốt lắm!

5. Vừa tìm hiểu cái vụ chuyển đổi kích thước này, thấy đoạn code này cũng hay, post lên nếu ai đó cần thì tham khảo thêm
C++ Code:
1. public int[] resizePixels(int[] pixels,int w1,int h1,int w2,int h2) {
2.     int[] temp = new int[w2*h2] ;
3.     // EDIT: added +1 to account for an early rounding problem
4.     int x_ratio = (int)((w1<<16)/w2) +1;
5.     int y_ratio = (int)((h1<<16)/h2) +1;
6.     //int x_ratio = (int)((w1<<16)/w2) ;
7.     //int y_ratio = (int)((h1<<16)/h2) ;
8.     int x2, y2 ;
9.     for (int i=0;i<h2;i++) {
10.         for (int j=0;j<w2;j++) {
11.             x2 = ((j*x_ratio)>>16) ;
12.             y2 = ((i*y_ratio)>>16) ;
13.             temp[(i*w2)+j] = pixels[(y2*w1)+x2] ;
14.         }
15.     }
16.     return temp ;
17. }

- Chú ý: ảnh được lưu dưới dạng mảng một chiều
Có thể tham khảo thêm ở đây

#### Quyền hạn của bạn

• Bạn không thể gửi đề tài mới
• Bạn không thể gửi bài trả lời
• Bạn không thể gửi các đính kèm
• Bạn không thể chỉnh sửa bài viết của bạn