//------------------------------------------------------------------------------------
//	DSt_cube<T>::writeToFile
//	Description - Writes cube to a file in its RAW form
//------------------------------------------------------------------------------------
template <class T>
dst_status	DSt_cube<T>::writeToFile(char* output_prefix, dst_options options=0)
{
	// Open file
	HANDLE	file_handle = OpenOutputFile(output_prefix, options);
	if ( file_handle == INVALID_HANDLE_VALUE )
	{
		return	DST_FILE_IO_ERROR;
	}
	
	DWORD	bytes_in_buffer;
	DWORD	bytes_written;

	// If file caching is used, make a one slice buffer for copying back and forth
	// (I could not get the CopyFile() function to work)
	if ( cache_state )
	{
		bytes_in_buffer = sizeof(T) * wX * wY;
		T	*buffer = new T [wX * wY];

		// Force a sync with file
		forceCacheSync();

		// Make sure we are at start of cache file
		LARGE_INTEGER	zero;		zero.QuadPart = 0;
		SetFilePointerEx( cache_file, zero, NULL, FILE_BEGIN );

		for (unsigned short z = 0; z < wZ; z++)
		{
			// Read in one slice from cache file
			ReadFile( cache_file, buffer, bytes_in_buffer, &bytes_written, NULL );
			// Write it to requested file
			WriteFile( file_handle, buffer, bytes_in_buffer, &bytes_written, NULL );
		}

		delete	buffer;
	}
	else
	{
		bytes_in_buffer = sizeof(T) * wX * wY * slices_per_block;

		for (unsigned short i = 0; i < memory_num_of_blocks; i++)
		{
			if (i == (memory_num_of_blocks-1) )
			{	// Last block might have different number of slices
				bytes_in_buffer = sizeof(T) * wX * wY * slices_per_block_last;
				WriteFile( file_handle, memory_block_ptrs[i], bytes_in_buffer, &bytes_written, NULL );
			}
			else
			{
				WriteFile( file_handle, memory_block_ptrs[i], bytes_in_buffer, &bytes_written, NULL );
			}
		}
	}
	
	CloseHandle( file_handle );
	return DST_NO_ERROR;
};


//------------------------------------------------------------------------------------
//	DSt_cube<T>::writeToFileRGB
//	Description - Writes cube to a file in RGB format, better looking but hard to know
//		true values.  Color intensity is blue -> blue/green -> green -> green/red -> red -> red/blue
//------------------------------------------------------------------------------------
template <class T>
dst_status	DSt_cube<T>::writeToFileRGB(char* output_prefix, T maxval/*=0*/, dst_options options, CProgressCtrl *progress_bar)
{
	// Open file
	HANDLE	file_handle = OpenOutputFile(output_prefix, options | DST_FILE_IS_RGB);
	if ( file_handle == INVALID_HANDLE_VALUE )
	{
		return	DST_FILE_IO_ERROR;
	}

	// Use a buffer the size of one RGB (24 bits per spot) slice to speed things up
	DWORD			bytes_written;
	DWORD			bytes_in_buffer = (DWORD) wX * wY * 3;
	unsigned char	*rgb_buffer	= new unsigned char[ bytes_in_buffer ];
	int				i = 0;
	unsigned short	z, y, x;
	double			ratio;

	// Setup progress bar, if provided
	if ( progress_bar )
	{
		progress_bar->SetPos(0);
		progress_bar->SetStep(1);
		progress_bar->SetRange(0, wZ);
	}

	// If max_val is 0, need to search entire cube for max
	if ( maxval == 0 )
	{
		FOR_wZwYwX_LOOP(this, z, y, x)
		{
			if ( datac(z, y, x) > maxval )
			{
				maxval = datac(z, y, x);
			}
		}
	}

	for (z = 0; z < wZ; z++)
	{
		for (y = 0; y < wY; y++)
		{
			for (x = 0; x < wX; x++)
			{				
				if ( datac(z, y, x) == 0 )
				{	// If 0, mark voxel as black
					rgb_buffer[i]	= 0;
					rgb_buffer[i+1] = 0;
					rgb_buffer[i+2] = 0;
				}
				else if ( datac(z, y, x) > maxval )
				{	// If 'maxval', mark voxel as white
					rgb_buffer[i]	= 255;
					rgb_buffer[i+1] = 255;
					rgb_buffer[i+2] = 255;
				}
				else
				{
					ratio = ( (double)datac(z, y, x) )/( maxval );

					// Intensity trend:
					//	blue -> blue/green -> green -> green/red -> red -> red/blue
					if (ratio < 1.0/6)
					{
						ratio = (ratio-0.0/6)*6;
						rgb_buffer[i]	= (unsigned char) 40;
						rgb_buffer[i+1]	= (unsigned char) 40;
						rgb_buffer[i+2]	= (unsigned char)(40+ratio*(255-40));
					}
					else if (ratio < 2.0/6)
					{
						ratio = (ratio-1.0/6)*6;
						rgb_buffer[i]	= (unsigned char) 40;
						rgb_buffer[i+1]	= (unsigned char)(40+ratio*(255-40));
						rgb_buffer[i+2]	= (unsigned char) 255;
					}
					else if (ratio < 3.0/6)
					{
						ratio = (ratio-2.0/6)*6;
						rgb_buffer[i]	= (unsigned char) 40;
						rgb_buffer[i+1]	= (unsigned char) 255;
						rgb_buffer[i+2]	= (unsigned char)(255-ratio*(255-40));
					}
					else if (ratio < 4.0/6)
					{
						ratio = (ratio-3.0/6)*6;
						rgb_buffer[i]	= (unsigned char)(40+ratio*(255-40));
						rgb_buffer[i+1]	= (unsigned char) 255;
						rgb_buffer[i+2]	= (unsigned char) 40;
					}
					else if (ratio < 5.0/6)
					{
						ratio = (ratio-4.0/6)*6;
						rgb_buffer[i]	= (unsigned char) 255;
						rgb_buffer[i+1]	= (unsigned char)(255-ratio*(255-40));
						rgb_buffer[i+2]	= (unsigned char) 40;
					}
					else
					{
						ratio = (ratio-5.0/6)*6;
						rgb_buffer[i]	= (unsigned char) 255;
						rgb_buffer[i+1]	= (unsigned char) 40;
						rgb_buffer[i+2]	= (unsigned char)(40+ratio*(255-40));
					}					
				}

				i += 3;
			}//end FOR X
		}//end FOR Y

		// After every full slice, dump to file
		WriteFile( file_handle, rgb_buffer, bytes_in_buffer, &bytes_written, NULL );
		i = 0;

		// Update progress
		if ( progress_bar )
		{
			progress_bar->StepIt();
		}

	}//end FOR Z
	
	CloseHandle( file_handle );
	delete[] rgb_buffer;

	return DST_NO_ERROR;
};


//------------------------------------------------------------------------------------
//	DSt_cube<T>::readFromFile
//	Description - Reads a file into the cube, format assumed to be correct.
//------------------------------------------------------------------------------------
template <class T>
dst_status	DSt_cube<T>::readFromFile(char *input_name, unsigned short start_at_files_z_index/*=0*/ )
{
	// Open file
	HANDLE	file_handle = CreateFile( input_name, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL );
	if( file_handle == INVALID_HANDLE_VALUE )
	{
		write_to_log("DSt_cube<T>::readFromFile - Cannot open input file, %s", input_name);
		return	DST_FILE_IO_ERROR;
	}

	LARGE_INTEGER	start_offset_bytes;
	DWORD			bytes_read;
	DWORD			bytes_to_read = sizeof(T) * wX * wY * slices_per_block;

	// Seek to desired file offset
	start_offset_bytes.QuadPart = (LONGLONG) sizeof(T) * start_at_files_z_index * wX * wY;
	SetFilePointerEx( file_handle, start_offset_bytes, NULL, FILE_BEGIN );

	// Read in data	
	for (unsigned short i = 0; i < memory_num_of_blocks; i++)
	{
		if (i == (memory_num_of_blocks-1) )
		{	// Last block might have different number of slices
			bytes_to_read = sizeof(T) * wX * wY * slices_per_block_last;
			ReadFile( file_handle, memory_block_ptrs[i], bytes_to_read, &bytes_read, NULL );
		}
		else
		{
			ReadFile( file_handle, memory_block_ptrs[i], bytes_to_read, &bytes_read, NULL );
		}
	}
	
	CloseHandle( file_handle );
	return DST_NO_ERROR;
};


//--------------------------------(PRIVATE)-------------------------------------------
//	DSt_cube<T>::OpenOutputFile	
//	Description - Appends cube dimensions and type to 'output_prefix' and opens
//		file for writing.
//------------------------------------------------------------------------------------
template <class T>
HANDLE	DSt_cube<T>::OpenOutputFile(char* output_prefix, dst_options options=0)
{
	if ( strlen(output_prefix) > MAX_FILE_STR_LEN-30 )
	{
		write_to_log("DSt_cube<T>::writeToFile - Provided output prefix too long, %s", output_prefix);
		return	NULL;
	}

	char file_name[MAX_FILE_STR_LEN];

	if ( options & DST_DO_NOT_APPEND_SIZE )
	{
		sprintf(file_name, "%s", output_prefix);
	}
	else
	{
		// If RGB specified, extension defaults to .u24.rgb
		if ( options&DST_FILE_IS_RGB )
		{
			sprintf(file_name, "%s(%d_%d_%d).u24.rgb", output_prefix, wX, wY, wZ);
		}
		else
		{	// Attempt to give appropriate extensions for signed/unsigned
			T test = (T)-1;
			if (test < 0)
				sprintf(file_name, "%s(%d_%d_%d).s%d.raw", output_prefix, wX, wY, wZ, sizeof(T)*8);
			else
				sprintf(file_name, "%s(%d_%d_%d).u%d.raw", output_prefix, wX, wY, wZ, sizeof(T)*8);
		}

		// Check if we need to update the file name
		if ( options & DST_UPDATE_FILE_NAME)
		{
			sprintf(output_prefix, "%s", file_name);
		}
	}

	// Create file
	HANDLE	file_handle = CreateFile( file_name, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_SEQUENTIAL_SCAN, NULL );
	if( file_handle == INVALID_HANDLE_VALUE )
	{
		write_to_log("DSt_cube<T>::OpenOutputFile - Cannot open output file, %s", file_name);
		return	NULL;
	}

	return	file_handle;
};