#include "LowPassFilter.h"

#include <mmStringUtilities.h>
#include <mmInterfaceInitializers.h>
#include <mmOperatingSystemCalls.h>

mmImages::cmLPF::cmLPF(mmMemory::mmMemoryManagerI* p_psMemoryManager,
                mmLog::mmLogReceiverI* p_psLogReceiver):
                mmCalcMethodI(p_psMemoryManager, 
                       p_psLogReceiver, 
                       mmString(L"cmLPF"))
{
 swprintf(m_sCMParams.sShortName, L"MT: Low pass filter");
 swprintf(m_sCMParams.sIDName, L"{7BD54E10-3BB7-4A57-BD75-C7E7D546CD28}");
 swprintf(m_sCMParams.sDescription,L"MT: Low pass filter");
 m_sCMParams.bIsMultithreaded = false;

 // put members initialization code here
 SetParam(L"Image name", mmXML::g_eXMLImageName, &m_sImage);
    SetParam(L"Layer name",mmXML::g_eXMLDataLayerName, &m_sLayer);
 // put parameters definition here

 UpdateParameters();
}

mmImages::cmLPF::~cmLPF()
{
}

bool mmImages::cmLPF::Calculate()
{
 // create calculation kernel
 //std::auto_ptr<mmImages::mmCalcKernelI> v_psKernel(new mmImages::mmKernelGeneric());
 
 // run calculation kernel for all data in the structure
 //ForEachImage(v_psKernel.get());

 //image parameters
 mmInt imageID, layerID, i_width, i_height, i_channels;
 mmReal *pixels;
 
 m_psImagesStructure->LockAllDataForRead();
 imageID = m_psImagesStructure->GetImageID(m_sImage);
 layerID = m_psImagesStructure->GetDataLayerID(m_sLayer);
 m_psImagesStructure->GetImageParameters(imageID,&i_width,&i_height,&i_channels);
 mmReal *original_pixels = new mmReal[i_width*i_height];
 mmReal *modified_pixels = new mmReal[i_width*i_height];
 m_psImagesStructure->GetPointsAdditionalDataLayerCoord(imageID,0,i_width*i_height,layerID,original_pixels);
 m_psImagesStructure->UnlockAllDataFromRead();

 pixels = new mmReal[i_width*i_height];
 std::fill(pixels,pixels+(i_width*i_height),0.0);
 std::fill(modified_pixels,modified_pixels+(i_width*i_height),0.0);
 //kernel parameters
 const mmInt radius = 1;
 const mmInt kernel_length = radius*2+1;
 const mmInt kernel_size = kernel_length*kernel_length;
 mmReal kernel_sum = 0.0;

 
 mmReal kernel[kernel_size];
 //create gaussian kernel  
 for (mmInt l=-radius;l<=radius;l++)
  for (mmInt c=-radius;c<=radius;c++)
  {
   for (mmInt i=0;i<=radius*2;i++)
   {
    if(abs(l)+abs(c)==i) 
    {
     //mmInt test = abs(l)+abs(c);
     mmReal exp_param =  (-1*mmReal(i))/(2*radius*radius);
     kernel[l*kernel_length+c+mmInt(kernel_size/2)]=(1/sqrt(2*3.14*radius*radius))*exp(exp_param); //gauss function
    }
   }
  }
 for (mmInt i=0;i<kernel_size;i++)
  {
   kernel_sum+=fabs(kernel[i]);
  }
 mmInt index_k; //kernel centered index
 mmInt index_k2;//kernel reg index
 mmInt index_p;//all pixels index
 mmInt index_m;//modified pixels index

 for (mmInt j=0;j<i_height;j++)
  for (mmInt i=0;i<i_width;i++)
  {
   index_m = j*i_width + i;
   if (j<=radius || j>=i_height-radius || i<=radius || i>=i_width-radius)
   {
    modified_pixels[index_m]=0.0;
    continue;
   }
   for (mmInt l=-radius;l<=radius;l++)
    for (mmInt c=-radius;c<=radius;c++)
    {
     index_k = l*kernel_length+c;
     index_k2 = index_k+mmInt(kernel_size/2);
     index_p = (j+l)*i_width + (i+c);
     pixels[index_p] = kernel[index_k2]*original_pixels[index_p];
     modified_pixels[index_m] += pixels[index_p];
    }
   modified_pixels[index_m]=fabs(modified_pixels[index_m])/kernel_sum;
  }

 m_psImagesStructure->LockAllDataForWrite();
 mmInt new_layerID;
 new_layerID = m_psImagesStructure->AddNewDataLayer(m_sLayer + L"_LPFiltered",0.0);
 m_psImagesStructure->SetPointsAdditionalDataLayerCoord(imageID,0,i_width*i_height,new_layerID,modified_pixels);
 m_psImagesStructure->UnlockAllDataFromWrite();
 m_psImagesStructure->LockAllDataForRead();
 m_psImagesStructure->UpdateImages();
    m_psImagesStructure->UnlockAllDataFromRead();

 delete [] original_pixels, modified_pixels, pixels, kernel;

 return true;
}

void mmImages::cmLPF::ExecBeforeSingleImageCalc(mmInt p_iCurrentImageID)
{
 // put code which runs before every image calculation here
}

void mmImages::cmLPF::ExecAfterSingleImageCalc(mmInt p_iCurrentImageID)
{
 // put code which runs after every image calculation here
}

void mmImages::cmLPF::RetrieveParameters()
{
 // update parameters value here after their change by the user
 GetParam(L"Image name", &m_sImage);
 GetParam(L"Layer name", &m_sLayer);
}

/*mmImages::mmKernelGeneric::mmKernelGeneric()
{
}

mmImages::mmKernelGeneric::~mmKernelGeneric()
{
}

void mmImages::mmKernelGeneric::operator()(mmImagesStructureI* p_psImagesStructure,
                      mmInt p_iCurrentImageID, 
                      mmInt p_iFirstRow,
                      mmInt p_iRowsCount)
{
 // here put code that runs on the image segment and performs all necessary calculations
}*/