/**************************************************************************************
 * File name: ImageDrawing.cpp
 *
 * Project: MapWindow Open Source (MapWinGis ActiveX control) 
 * Description: Implementation of CImageDrawer
 *
 **************************************************************************************
 * The contents of this file are subject to the Mozilla Public License Version 1.1
 * (the "License"); you may not use this file except in compliance with 
 * the License. You may obtain a copy of the License at http://www.mozilla.org/mpl/ 
 * See the License for the specific language governing rights and limitations
 * under the License.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 **************************************************************************************/
  
#include "stdafx.h"
#include <io.h>
#include "Image.h"
#include "ImageDrawing.h"
#include "macros.h"
#include "ImageHelper.h"

// ******************************************************************
//		DrawImage()
// ******************************************************************
ScreenBitmap* CImageDrawer::DrawImage(const CRect & rcBounds, IImage* img, bool returnBitmap)
{
	if( img == NULL )
		return NULL;

	if (ImageHelper::Cast(img)->GetBufferReloadIsNeeded())
	{				
		img->SetVisibleExtents(_extents->left, _extents->bottom, _extents->right, _extents->top, GetPixelsInView(), 0.0);
	}
	
	ImageSpecs specs;

	// width, height, dx, dy, xllCorner, yllCorner
	if (!ReadImageSpecs(img, specs)) 
	{
		return NULL;
	}
	
	if (!WithinVisibleExtents(specs.xllCorner, specs.GetXtrCorner(), specs.yllCorner, specs.GetYtrCorner())) 
	{
		return NULL;
	}
	
	_graphics->SetPixelOffsetMode(Gdiplus::PixelOffsetModeHighQuality);
	
	Gdiplus::ImageAttributes* imgAttr = ImageHelper::GetImageAttributes(img);

	ScreenBitmap* screenBitmap = NULL;
	if(!ImageHelper::GetIsInRam(img) && ImageHelper::GetImageType(img) == BITMAP_FILE)
	{
		DrawBmpNative(img, specs, imgAttr, rcBounds);
	}
    else
	{	
		int bitsPerPixel = 32;		

		IImage* imgTemp = CreateSmallerProxyForGdalRaster(specs, img, rcBounds, bitsPerPixel / 8);

		ScreenBitmap* screenBitmap = DrawGdalRaster(imgTemp != NULL ? imgTemp : img, specs, imgAttr, rcBounds, bitsPerPixel, returnBitmap);
		if (screenBitmap) {
			delete screenBitmap;
		}

		if (imgTemp) {
			imgTemp->Release();
		}
	}

	delete imgAttr;
	
	return returnBitmap ? screenBitmap : NULL;	// returning bitmap to draw in case of grouped images
}

// ******************************************************************
//		DrawGdalRaster()
// ******************************************************************
ScreenBitmap* CImageDrawer::DrawGdalRaster(IImage* iimg, ImageSpecs& specs, Gdiplus::ImageAttributes* imgAttr, CRect rcBounds, int bitsPerPixel, bool returnBitmap)
{
	ScreenBitmap* screenBitmap = NULL;

	ImageType type = ImageHelper::GetImageType(iimg);
	
	double mapL, mapT, mapR, mapB;	// map units w/o clipping (world coordinates to place the image)
	double dstL, dstR, dstT, dstB;	// screen units with clipping (area needed to draw visible part)
	int imgX, imgY, imgW, imgH;	// image units with clipping (part of image to draw)
	
	//  accessing data from the buffer
	unsigned char* pData = ImageHelper::GetImageData(iimg);
	colour* pNewData = NULL;

	// try to load the buffer, as we could fail to load it because of unsuccessful image grouping
	if (!pData && (type != BITMAP_FILE && type != USE_FILE_EXTENSION))
	{
		iimg->SetVisibleExtents(_extents->left, _extents->bottom, _extents->right, _extents->top, GetPixelsInView(), 0.0);
		CallbackHelper::AssertionFailed("DrawGdalRaster: no buffer was populated.");
	}

	if (!pData) return NULL;

	int pad = ImageHelper::GetRowBytePad(specs.width, bitsPerPixel);

	// ------------------------------------------------------------
	//    Drawing blocks of the bitmap
	// ------------------------------------------------------------
	int blockSize = 8192;
	long numRead;					// number of rows read
	for (int row = 0; row < specs.height;)
	{
		numRead = blockSize;
		if (row + blockSize >= specs.height)
			numRead = specs.height - row;

		// part of image to draw in map units
		mapL = specs.xllCorner;
		mapB = specs.yllCorner + row * specs.dy;
		mapT = mapB + (double)numRead * specs.dy;
		mapR = mapL + (double)specs.width * specs.dx;

		if (WithinVisibleExtents(mapL, mapR, mapB, mapT))
		{
			Extent extImage = Extent(mapL, mapR, mapB, mapT);
			CalculateImageBlockSize(extImage, _extents->left, _extents->bottom, _extents->right, _extents->top, specs.dx, specs.dy, numRead, specs.width);

			imgX = _visibleRect.left;
			imgY = _visibleRect.top;
			imgW = _visibleRect.right - _visibleRect.left + 1;
			imgH = _visibleRect.bottom - _visibleRect.top + 1;

			ProjectionToPixel(_visibleExtents.left, _visibleExtents.bottom, dstL, dstB);
			ProjectionToPixel(_visibleExtents.right, _visibleExtents.top, dstR, dstT);

			double dstW = imgW * specs.dx * _pixelPerProjectionX;
			double dstH = imgH * specs.dy * _pixelPerProjectionY;

			_graphics->SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);

			unsigned char* bits = ReadGdalBufferBlock(pData, row, specs.width, bitsPerPixel / 8, pad, numRead);

			// choosing sampling method		
			int bmp = type == BITMAP_FILE || type == USE_FILE_EXTENSION;
			int w = bmp ? specs.width : ImageHelper::Cast(iimg)->GetOriginalBufferWidth();
			int h = bmp ? specs.height : ImageHelper::Cast(iimg)->GetOriginalBufferHeight();
			bool downsampling = double(dstR - dstL) * double(dstB - dstT) < (double)(w * h);
			_graphics->SetInterpolationMode(ImageHelper::GetInterpolationMode(iimg, !downsampling));

			int stride = specs.width * bitsPerPixel / 8 + pad;

			Gdiplus::Bitmap imgPlus(specs.width, numRead, stride, PixelFormat32bppARGB, reinterpret_cast<BYTE*>(bits));

			if (returnBitmap)
			{
				screenBitmap = CreateScreenBitmap(dstL, dstT, dstW, dstH);

				Gdiplus::Graphics g(screenBitmap->bitmap);
				g.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
				g.SetInterpolationMode(ImageHelper::GetInterpolationMode(iimg, !downsampling));

				DrawGdalImage(&g, &imgPlus, imgAttr, dstL, dstT, dstW, dstH, imgX, imgY, imgH, imgW, true);

				_graphics->DrawImage(screenBitmap->bitmap, (Gdiplus::REAL)screenBitmap->left, (Gdiplus::REAL)screenBitmap->top);
			}
			else
			{
				DrawGdalImage(_graphics, &imgPlus, imgAttr, dstL, dstT, dstW, dstH, imgX, imgY, imgH, imgW, false);
			}

			if (pad != 0)	// otherwise we were using the buffer directly
			{
				delete[] bits;		
			}
		}
		
		// going to the next block
		row += numRead;
	}

	return screenBitmap;
}

// ******************************************************************
//		DrawGdalImage()
// ******************************************************************
void CImageDrawer::DrawGdalImage(Gdiplus::Graphics* g, Gdiplus::Image* img, Gdiplus::ImageAttributes* imgAttr,
								double dstL, double dstT, double dstW, double dstH, 
								int imgX, int imgY, int imgH, int imgW, bool atOrigin)
{
	if (atOrigin)
	{
		dstL = 0;
		dstT = 0;
	}

	Gdiplus::RectF rect((Gdiplus::REAL)int(dstL),
					    (Gdiplus::REAL)int(dstT), 
						(Gdiplus::REAL)int(dstW + 1.0), 
						(Gdiplus::REAL)int(dstH + 1.0));

	g->DrawImage(img, rect, 
				(Gdiplus::REAL)(imgX), 
				(Gdiplus::REAL)(imgY),
				(Gdiplus::REAL)imgW, 
				(Gdiplus::REAL)imgH, 
				Gdiplus::UnitPixel, 
				imgAttr);
}

// ******************************************************************
//		CreateScreenBitmap()
// ******************************************************************
ScreenBitmap* CImageDrawer::CreateScreenBitmap(double dstL, double dstT, double dstW, double dstH)
{
	ScreenBitmap* screenBitmap = new ScreenBitmap();
	screenBitmap->left = int(dstL);
	screenBitmap->top = int(dstT);
	screenBitmap->pixelPerProjectionX = _pixelPerProjectionX;
	screenBitmap->pixelPerProjectionY = _pixelPerProjectionY;
	screenBitmap->viewHeight = _viewHeight;
	screenBitmap->viewWidth = _viewWidth;
	screenBitmap->extents = *_extents;
	screenBitmap->bitmap = new Gdiplus::Bitmap((INT)(dstW + 1.0), (INT)(dstH + 1.0));
	return screenBitmap;
}

// ******************************************************************
//		ReadGdalBlock()
// ******************************************************************
// allocated new buffer in case padding isn't 0
unsigned char* CImageDrawer::ReadGdalBufferBlock(unsigned char* buffer, int row, int width, int bytesPerPixel, int pad, int numRead)
{
	unsigned char* bits = (unsigned char*)(&buffer[row * width * bytesPerPixel]);

	if (pad == 0) {
		return bits;
	}
	
	// we can make number of image buffer pixels in row dividable by 4 them we don't need this condition
	int nBytesInRow = width * bytesPerPixel + pad;
	
	unsigned char* bitsNew = new unsigned char[nBytesInRow * numRead];
	for (int i = 0; i < numRead; i++) 
	{
		memcpy(&bitsNew[i * nBytesInRow], &bits[i * width * bytesPerPixel], width * bytesPerPixel);
	}

	return bitsNew;
}

// ******************************************************************
//		CreateSmallerProxyForGdalRaster()
// ******************************************************************
//	Creating temporary instance of image class holding 
//	the area to display. Don't forget to release it after!!!
//  Is used for grouped images first of all
IImage* CImageDrawer::CreateSmallerProxyForGdalRaster(ImageSpecs& specs, IImage* img, CRect rcBounds, int bytesPerPixel)
{
	double mapL, mapT, mapR, mapB;	// map units w/o clipping (world coordinates to place the image)
	double scrL, scrT, scrR, scrB;	// screen units  after projection w/o clipping (area needed to draw all the image)
	int dstL, dstR, dstT, dstB;	// screen units with clipping (area needed to draw visible part)
	int imgX, imgY, imgW, imgH;	// image units with clipping (part of image to draw)

	// part to draw in map units
	mapL = specs.xllCorner;
	mapB = specs.yllCorner;
	mapT = mapB + specs.height * specs.dy;
	mapR = mapL + specs.width * specs.dx;

	ProjectionToPixel(mapL, mapT, scrL, scrT);
	ProjectionToPixel(mapR, mapB, scrR, scrB);

	dstL = (int)scrL;
	dstT = (int)scrT;
	dstR = (int)scrR; dstB = (int)scrB;

	imgX = imgY = 0;
	imgW = specs.width;
	imgH = specs.height;

	CalculateImageBlockSize(dstL, dstT, dstR, dstB, imgX, imgY, imgW, imgH, mapL, mapT, mapR, mapB, specs.dx, specs.dy, rcBounds);

	if (imgW * imgH * 2.0 > specs.width * specs.height)
	{
		// no need to copy data; we need to show almost all bitmap
		return NULL;
	}
	
	// **************************************************
	// copying part of the bitmap which will be used
	// **************************************************
	unsigned char* pData = ImageHelper::GetImageData(img);
	if (!pData)	{
		return NULL;
	}

	unsigned char* pDataTemp = NULL;
	colour* pColours = NULL;

	try	{
		pColours = new colour[imgW * imgH];
	}
	catch (...)
	{
		CallbackHelper::ErrorMsg("Drawing GDAL raster: failed to allocated memory buffer.");
		return NULL;
	}

	pDataTemp = reinterpret_cast<unsigned char*>(pColours);
	for (int n = 0; n < imgH; n++)
	{
		memcpy(pDataTemp + n * imgW * bytesPerPixel,
			pData + (imgY + n) * specs.width * bytesPerPixel + imgX * bytesPerPixel,
			imgW * bytesPerPixel);
	}

	// ---------------------------------------------------------
	//	  preparing new class to save results
	// ---------------------------------------------------------
	IImage* imgNew = NULL;
	CoCreateInstance(CLSID_Image, NULL, CLSCTX_INPROC_SERVER, IID_IImage, (void**)&imgNew);

	VARIANT_BOOL vb;
	imgNew->CreateNew(imgW, imgH, &vb);
	if (!vb)
	{
		imgNew->Release();
		delete[] pColours;
		return NULL;
	}

	// passing the data to image class
	ImageHelper::PutImageData(imgNew, pColours);

	// setting the properties of the new bitmap
	double projX, projY;
	PixelToProjection(dstL, dstB, projX, projY);

	specs.xllCorner = projX;
	specs.yllCorner = projY;

	imgNew->put_XllCenter(specs.xllCorner);
	imgNew->put_YllCenter(specs.yllCorner);

	specs.width = imgW;
	specs.height = imgH;

	return imgNew;
}

// ******************************************************************
//		GetPixelsInView()
// ******************************************************************
long CImageDrawer::GetPixelsInView()
{
	return static_cast<long>(_extents->Width() * _pixelPerProjectionX * _extents->Height() * _pixelPerProjectionY);
}

// ******************************************************************
//		CalculateImageBlock()
// ******************************************************************
// Calculates the part of image to draw (img) and the screen rectangular to draw (dst)
// uses dimensions of block in map coordinates (map)
bool CImageDrawer::CalculateImageBlockSize(int& dstL, int& dstT, int& dstR, int& dstB, 
								   int& imgX, int& imgY, int& imgW, int& imgH, 
						           double& mapL, double& mapT, double& mapR, double& mapB,
								   const double dx, const double dy, const CRect& rcBounds)
{
	double fraction = 0.0;
	double imgCellsHidden;
	int offset;
	double hiddenRange;

	if( dstL < -1 )			//adjust the left side
	{
		hiddenRange = _extents->left - mapL;								// in world coordinates
		imgCellsHidden = hiddenRange/dx;								//in img cells
		fraction = imgCellsHidden - (int)imgCellsHidden;				//fraction of cell off screen (in img cells)
		offset = int(fraction * dx * _pixelPerProjectionX);					//screen pixels needed off screen
		dstL = static_cast<int>(rcBounds.left - offset + 0.5);			//adjusted drawing area
		imgX = (int)imgCellsHidden;										//new img starting index
		imgW -= (int)imgCellsHidden;									//chop off hidden cells from width
	}
	if( dstT < -1 )			//adjust the top
	{
		hiddenRange = mapT - _extents->top;					// in world coordinates
		imgCellsHidden = hiddenRange/dy;					//in img cells
		fraction = imgCellsHidden - (int)imgCellsHidden;	//fraction of cell off screen (in img cells)
		offset = int(fraction * dy * _pixelPerProjectionY);		//screen pixels needed off screen
		dstT = static_cast<int>(rcBounds.top - offset + 0.5);						//adjusted drawing area
		imgY = (int)imgCellsHidden;							//new img starting index
		imgH -= (int)imgCellsHidden;							//chop off hidden cells from width
	}
	if( dstR > _viewWidth )	//adjust the right side
	{
		hiddenRange = mapR - _extents->right;					//in world coordinates
		imgCellsHidden = hiddenRange /dx;					//in img cells
		fraction = imgCellsHidden - (int)imgCellsHidden;	//fraction of cell off screen
		offset = int(fraction * dx * _pixelPerProjectionX);		//screen pixels needed off screen
		dstR = static_cast<int>(rcBounds.right + offset + 0.5);						//adjusted drawing area
		imgW -=(int)imgCellsHidden;
	}
	if( dstB > _viewHeight )	//adjust the bottom side
	{
		hiddenRange = _extents->bottom - mapB;					//in world coordinates
		imgCellsHidden = hiddenRange /dy;					//in img cells
		fraction = imgCellsHidden - (int)imgCellsHidden;	//the fraction of a cell that is hidden
		offset = int(fraction * dy * _pixelPerProjectionY);		//screen pixels out of view
		dstB = static_cast<int>(rcBounds.bottom + offset + 0.5);					//adjust the drawing area
		imgH -= (int)imgCellsHidden;
	}
	
	return true;
}

// ***********************************************************
//		CalculateImageBlockSize()
// ***********************************************************
// extent - extents of the image block in map coordinates;
// minX, etc - visible extents in map coordinates
// Goal - to find which pixels of the image will be visible (_visibleRect in image coordinates)
// and to what map coordinates they correspond (_visibleExtents in map coordinates)
// The conversion to the screen coordinates can be made with standard means
bool CImageDrawer::CalculateImageBlockSize(Extent extents, double MinX, double MinY, double MaxX, double MaxY,
										   const double dX, const double dY, const int height, const int width)
{
	int hiddenPixels;
	
	_visibleExtents.left = extents.left;
	_visibleRect.left = 0;
	if (extents.left < MinX) 
	{	
		hiddenPixels = int((MinX - extents.left)/dX);		// how many pixels are completely hidden: rounding in the lower side
		_visibleExtents.left += (double)hiddenPixels * dX;
		_visibleRect.left += hiddenPixels;
	}
    
	_visibleExtents.bottom = extents.bottom;
	_visibleRect.bottom = height - 1;
	if (extents.bottom < MinY)
	{	
		hiddenPixels = int((MinY - extents.bottom)/dY);	// how many pixels are completely hidden: rounding in the lower side
		_visibleExtents.bottom +=  (double)hiddenPixels * dY;
		_visibleRect.bottom -= hiddenPixels;
	}
	
	_visibleExtents.right = extents.right;
	_visibleRect.right = width - 1;
	if (extents.right > MaxX) 
	{	
		hiddenPixels = int((extents.right - MaxX)/dX);		// how many pixels are completely hidden: rounding in the lower side
		_visibleExtents.right -= (double)hiddenPixels * dX;
		_visibleRect.right -= hiddenPixels;
	}

	_visibleExtents.top = extents.top;
	_visibleRect.top = 0;
	if (extents.top > MaxY)
	{	
		hiddenPixels = int((extents.top-MaxY)/ dY);		// how many pixels are completely hidden: rounding in the lower side
		_visibleExtents.top -=  (double)hiddenPixels * dY;
		_visibleRect.top += hiddenPixels;
	}

	return true;
}

// ***********************************************************
//		WithinVisibleExtents()
// ***********************************************************
bool CImageDrawer::WithinVisibleExtents(double xMin, double xMax, double yMin, double yMax)
{
	return 	!(xMin > _extents->right || xMax < _extents->left || yMin > _extents->top || yMax < _extents->bottom);
}

// ******************************************************************
//		ReadImageSpecs()
// ******************************************************************
bool CImageDrawer::ReadImageSpecs(IImage* img, ImageSpecs& specs)
{
	long width, height;
	img->get_Width(&width);
	img->get_Height(&height);

	if (width <= 0 || height <= 0)
		return false;

	double dx = 0, dy = 0;
	img->get_dX(&dx);
	img->get_dY(&dy);
	if (dx <= 0.0 || dy <= 0.0)
		return false;

	double xllCorner, yllCorner;	// in projected coordinates
	img->get_XllCenter(&xllCorner);
	img->get_YllCenter(&yllCorner);
	xllCorner -= dx*.5;
	yllCorner -= dy*.5;

	specs.dx = dx;
	specs.dy = dy;
	specs.xllCorner = xllCorner;
	specs.yllCorner = yllCorner;
	specs.width = width;
	specs.height = height;

	return true;
}

// ******************************************************************
//		DrawBmpNative()
// ******************************************************************
void CImageDrawer::DrawBmpNative(IImage* img, ImageSpecs& specs, Gdiplus::ImageAttributes* imgAttr, CRect rcBounds)
{
	long blockSize = 4096;	//blockSize = 1024; there is better performance the first time read @ 1024

	FILE * imgfile = NULL;
	long fileHandle = -1;
	img->get_FileHandle(&fileHandle);
	if (fileHandle >= 0)
	{
		USES_CONVERSION;
		CComBSTR fname;
		img->get_Filename(&fname);
		imgfile = ::_wfopen(OLE2CW(fname), L"rb");
	}

	unsigned char * data = NULL;
	BITMAPFILEHEADER bmfh;
	BITMAPINFOHEADER bmif;
	RGBQUAD * bmiColors = NULL;
	BITMAPINFO * bi = NULL;

	if (!imgfile)
		goto clear_bmp;

	//read in BITMAPFILEHEADER
	fread(&bmfh, sizeof(BITMAPFILEHEADER), 1, imgfile);

	//if not a valid bitmap file, fail to load
	if (bmfh.bfType != 19778)
	{
		CallbackHelper::ErrorMsg("Invalid BMP file. bmfh.bfType = 19778 was expected.");
		goto clear_bmp;
	}

	//read in BITMAPINFOHEADER
	fread(&bmif, sizeof(BITMAPINFOHEADER), 1, imgfile);
	bmif.biClrUsed = (bmfh.bfOffBits - 54) / 4;
	if (bmif.biClrUsed != 0)
	{
		bmiColors = new RGBQUAD[bmif.biClrUsed];
		fread(bmiColors, sizeof(RGBQUAD), bmif.biClrUsed, imgfile);
	}

	//Read to the beginning of the data
	int sizeof_header = 54;
	int n = bmfh.bfOffBits - (54 + bmif.biClrUsed * 4);
	if (n > 0) {
		fseek(imgfile, n, SEEK_CUR);
	}

	// Read the specific bit count type
	long rowLength = GetBmpRowLength(specs.width, bmif.biBitCount);
	
	//Compute the pad
	int pad = ImageHelper::GetRowBytePad(bmif.biWidth, bmif.biBitCount);

	// ------------------------------------------------------
	//	 Preparing variables
	// ------------------------------------------------------
	data = new unsigned char[(rowLength + pad)*blockSize];
	long numRead;				// number of rows read

	double mapL, mapT, mapR, mapB;	// map units w/o clipping (world coordinates to place the image)
	double scrL, scrT, scrR, scrB;	// screen units  after projection w/o clipping (area needed to draw all the image)
	int dstL, dstR, dstT, dstB;	// screen units with clipping (area needed to draw visible part)
	int imgX, imgY, imgW, imgH;	// image units with clipping (part of image to draw)

	bi = new BITMAPINFO;		//SetDIBits variable
	bi = (BITMAPINFO*)realloc(bi, sizeof(BITMAPINFO) + sizeof(RGBQUAD)* bmif.biClrUsed);	//This adjusts the bi.bmiColors to the right size of array

	// -----------------------------------------------
	//    Start drawing
	// -----------------------------------------------
	for (int row = 0; row < specs.height;)
	{
		numRead = blockSize;
		if (row + blockSize >= specs.height)
			numRead = specs.height - row;

		// part to draw in map units
		mapL = specs.xllCorner;
		mapB = specs.yllCorner + row * specs.dy;
		mapT = mapB + numRead * specs.dy;
		mapR = mapL + specs.width * specs.dx;

		ProjectionToPixel(mapL, mapT, scrL, scrT);
		ProjectionToPixel(mapR, mapB, scrR, scrB);

		if (row != 0) scrB++;

		fread(data, sizeof(unsigned char), (rowLength + pad)*numRead, imgfile);
		bi->bmiHeader = bmif;
		bi->bmiHeader.biHeight = numRead;
		bi->bmiHeader.biSizeImage = (rowLength + pad)*numRead;
		memcpy(bi->bmiColors, bmiColors, sizeof(RGBQUAD)*bmif.biClrUsed);

		if (WithinVisibleExtents(mapL, mapR, mapB, mapT))
		{
			dstL = (int)scrL;
			dstT = (int)scrT;
			dstR = (int)scrR;
			dstB = (int)scrB;

			imgX = 0;
			imgY = 0;
			imgW = specs.width;
			imgH = numRead;

			CalculateImageBlockSize(dstL, dstT, dstR, dstB, imgX, imgY, imgW, imgH, mapL, mapT, mapR, mapB, specs.dx, specs.dy, rcBounds);

			double destSize = double(dstR - dstL) * double(dstB - dstT);

			Gdiplus::InterpolationMode mode = ImageHelper::GetInterpolationMode(img, destSize > (imgW * imgH));
			_graphics->SetInterpolationMode(mode);

			Gdiplus::Bitmap imgPlus(bi, (void*)data);
			Gdiplus::RectF rect((Gdiplus::REAL)dstL, (Gdiplus::REAL)dstT, (Gdiplus::REAL)dstR - dstL, (Gdiplus::REAL)dstB - dstT);
			_graphics->DrawImage((Gdiplus::Image*)&imgPlus, rect, (Gdiplus::REAL)(imgX /*- 0.5*/), (Gdiplus::REAL)(imgY /*-0.5*/),
				(Gdiplus::REAL)imgW, (Gdiplus::REAL)imgH, Gdiplus::UnitPixel, imgAttr);
		}
		row += numRead;
	}

	// --------------------------------------------------
	//	   Cleaning
	// --------------------------------------------------
clear_bmp:
	if (bi) {
		delete bi;
	}

	if (bmiColors) {
		delete[] bmiColors;
	}

	if (data) {
		delete[] data;
	}

	if (imgfile) {
		fclose(imgfile);
	}

	if (fileHandle > 0)	{
		_close(fileHandle);
	}
}

// ******************************************************************
//		GetBmpRowLength()
// ******************************************************************
int CImageDrawer::GetBmpRowLength(int width, int bitsPerPixel)
{
	long rowLength = width;
	
	if (bitsPerPixel == 24)	
	{
		rowLength *= 3;
	}
	else if (bitsPerPixel == 8)	
	{
		// do nothing
	}
	else if (bitsPerPixel == 1)	
	{
		rowLength = (long)ceil(((double)width) / 8);
	}
	else if (bitsPerPixel == 4)
	{
		rowLength = int((double)rowLength * .5);
		if (width % 2) {
			rowLength++;
		}
	}
	
	return rowLength;
}