#include "fileout.h"
//#include "scalarfield.h"


/*void fileoutStruct::saveMag(fieldslice* U, std::string filename, rts::colormap::colormapType cmap)
{
    int Rx = U->R[0];
    int Ry = U->R[1];

	//allocate space for a scalar field on the GPU
	ptype* gpuScalar;
	int memsize = sizeof(ptype) * Rx * Ry;
	HANDLE_ERROR(cudaMalloc((void**) &gpuScalar, memsize));
	HANDLE_ERROR(cudaMemset(gpuScalar, 0, memsize));
	U->Mag(gpuScalar);


	rts::colormap::gpu2image<ptype>(gpuScalar, filename, Rx, Ry, 0, colorMax, cmap);

	HANDLE_ERROR(cudaFree(gpuScalar));
}

void fileoutStruct::saveReal_scalar(fieldslice* U, std::string filename, rts::colormap::colormapType cmap)
{
	//returns the real component
	scalarslice sf = U->Real();
	sf.toImage(filename, false, cmap);

}

void fileoutStruct::saveImag_scalar(fieldslice* U, std::string filename, rts::colormap::colormapType cmap)
{
	//returns the imaginary component of a field (assumed scalar)
	scalarslice sf = U->Imag();
	sf.toImage(filename, false, cmap);
}

void fileoutStruct::saveIntensity(fieldslice* U, std::string filename, rts::colormap::colormapType cmap)
{
	//get the intensity of the field
    scalarslice sf = U->Intensity();
	sf.toImage(filename, true, cmap);
}

void fileoutStruct::saveAngularSpectrum(fieldslice* U, std::string filename, rts::colormap::colormapType cmap)
{
    ptype* gpuScalar;
    int memsize = sizeof(ptype) * U->R[0] * U->R[1];
	HANDLE_ERROR(cudaMalloc((void**) &gpuScalar, memsize));
	HANDLE_ERROR(cudaMemset(gpuScalar, 0, memsize));

	//convert the field slice to its angular spectrum
	U->toAngularSpectrum();

	//convert the angular spectrum to a scalar field
	U->Mag(gpuScalar);

	//save the color image
	rts::colormap::gpu2image<ptype>(gpuScalar, filename, U->R[0], U->R[1], 0, colorMax, cmap);

	HANDLE_ERROR(cudaFree(gpuScalar));

}*/

void fileoutStruct::saveNearField(nearfieldStruct* nf)
{
    if(nearFile == "") return;

    if(field == fieldReal)
    {
        scalarslice S = nf->U.Real();
        S.toImage(nearFile, false, colormap);
    }
    if(field == fieldImag)
    {
        scalarslice S = nf->U.Imag();
        S.toImage(nearFile, false, colormap);
    }
    if(field == fieldMag)
    {
        scalarslice S = nf->U.Mag();
        S.toImage(nearFile, true, colormap);
    }
}

void fileoutStruct::saveFarField(microscopeStruct* scope)
{
    if(farFile == "") return;

    if(field == fieldReal)
    {
        scalarslice S = scope->Ud.Real();
        S.toImage(farFile, false, colormap);
    }
    if(field == fieldImag)
    {
        scalarslice S = scope->Ud.Imag();
        S.toImage(farFile, false, colormap);
    }
    if(field == fieldMag)
    {
        scalarslice S = scope->Ud.Mag();
        S.toImage(farFile, true, colormap);
    }

}

void fileoutStruct::saveDetector(microscopeStruct* scope)
{
	//intensity
    if(intFile != "")
    {
        scalarslice I = scope->getIntensity();

        if(is_binary(intFile))
		{
			if(wavenumber)
				I.toEnvi(intFile, 10000.0f/scope->nf.lambda, append);
			else
				I.toEnvi(intFile, scope->nf.lambda, append);
		}
		else
			I.toImage(intFile);
    }
    //absorbance
    if(absFile != "")
    {
        scalarslice I = scope->getAbsorbance();

        if(is_binary(absFile))
        {
			if(wavenumber)
				I.toEnvi(absFile, 10000.0f/scope->nf.lambda, append);
			else
				I.toEnvi(absFile, scope->nf.lambda, append);
		}
        else
            I.toImage(absFile);
    }
    //transmittance
    if(transFile != "")
    {
        scalarslice I = scope->getTransmittance();

        if(is_binary(transFile))
        {
			if(wavenumber)
				I.toEnvi(transFile, 10000.0f/scope->nf.lambda, append);
			else
				I.toEnvi(transFile, scope->nf.lambda, append);
		}
        else
            I.toImage(transFile);
    }

}

bool fileoutStruct::is_binary(std::string filename)
{
    //this function guesses if a file name is binary or a standard image
    //  do this by just testing extensions

    //get the extension
    size_t i = filename.find_last_of('.');

    //if there is no extension, return true
    if( i == std::string::npos )
        return true;

    //otherwise grab the extension
    std::string ext = filename.substr(i+1);
    if(ext == "bmp" ||
       ext == "jpg" ||
       ext == "tif" ||
       ext == "gif" ||
       ext == "png")
       return false;
    else
        return true;
}



void fileoutStruct::Save(microscopeStruct* scope)
{
	//save images of the fields in the microscope

	//if the user specifies an extended source
	if(scope->focalPoints.size() > 0)
	{
		//simulate the extended source and output the detector image
		scope->SimulateExtendedSource();

		//saveNearField(&scope->nf);
		saveFarField(scope);

		//save the detector images
		saveDetector(scope);

		//simulate scattering for the last point (so that you have a near field image)
		scope->SimulateScattering();
        saveNearField(&scope->nf);

	}
	else
	{
		//run the near-field simulation
		scope->SimulateScattering();

		//output the near field image
		saveNearField(&scope->nf);

		//run the far-field simulation
		scope->SimulateImaging();

		//saveNearField(&scope->nf);
		saveFarField(scope);

		//save the detector images
		saveDetector(scope);

	}

	


}