// Copyright (C) 2015, Antoni Buades, Universitat Illes Balears
// // <toni.buades@uib.es>
// //
// //
// //
// // This program is free software: you can use, modify and/or
// // redistribute it under the terms of the GNU General Public
// // License as published by the Free Software Foundation, either
// // version 3 of the License, or (at your option) any later
// // version. You should have received a copy of this license along
// // this program. If not, see <http://www.gnu.org/licenses/>.
//
//
//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "library/libImage.h"
#include "library/libBasic.h"
#include "library/libCartoon.h"

/*******************************************************************************
MAIN PROGRAM
Input parameters:
* input image
* i flag (optional): if active then add isotropic filter to filter bank
* sigma: scale parameter
Output parameters:
* cartoon image
* texture image

 Example of usage:
 src_cartoon_plus_texture_newdirectional -i input cartoon texture 2

*******************************************************************************/
int main(int argc, char **argv)
{


    std::vector <OptStruct *> options;
    OptStruct oI = {"i", 0, NULL, NULL,
                    "flag for adding isotropic kernel to the bank of filters"};
    options.push_back(&oI);


    std::vector<ParStruct *> parameters;
    ParStruct pInput = {"input", NULL, "input image"};
    parameters.push_back(&pInput);
    ParStruct pCartoon = {"cartoon", NULL, "output cartoon image"};
    parameters.push_back(&pCartoon);
    ParStruct pTexture = {"texture", NULL, "output texture image"};
    parameters.push_back(&pTexture);
    ParStruct pSigma = {"sigma", NULL, "input texture scale"};
    parameters.push_back(&pSigma);



    if (!parsecmdline("src_cartoon_plus_texture_newdirectional", \
          "Cartoon+texture decomposition with non-linear directional filters", \
                      argc, argv, options, parameters))
        return 0;


    //! Parameters
    float fSigma = atof(pSigma.value);
    int iflag2D = oI.flag;


    //! Input
    libUSTG::cflimage cflInput;
    cflInput.load(pInput.value);



    //! Output
    libUSTG::cflimage cflTexture = cflInput;
    libUSTG::cflimage cflCartoon = cflInput;

    float fAngle = 8;
    libUSTG::non_linear_cartoon_newdirectional(cflInput, cflCartoon, \
                                               fSigma, fAngle, iflag2D);



    //! compute texture as difference
    for (int ii=0; ii < cflInput.whc(); ii++) {

        cflTexture[ii] = cflInput[ii] - cflCartoon[ii];

        //linearly map from [-20, 20] to [0, 255], for display
        //saturate values outside this range
        float range=20.0f;
        if (cflTexture[ii] < -range) cflTexture[ii]=-range;
        if (cflTexture[ii] > range) cflTexture[ii]=range;

        cflTexture[ii]=(cflTexture[ii]+range)*255.0f/(2*range);

    }




    cflTexture.save( pTexture.value);
    cflCartoon.save( pCartoon.value);

}