/****************************************************************************
 Copyright (C) 2010-2012 the Office National des Forêts (ONF), France
                         All rights reserved.

 Contact : alexandre.piboule@onf.fr

 Developers : Alexandre PIBOULE (ONF)

 This file is part of PluginONF library.

 PluginONF is free library: you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 PluginONF is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with PluginONF.  If not, see <http://www.gnu.org/licenses/lgpl.html>.
*****************************************************************************/

#include "onf_steprefineresolution.h"

ONF_StepRefineResolution::ONF_StepRefineResolution() : SuperClass()
{
    _name = tr("Refined raster");
    _rasterType = "none";
}

QString ONF_StepRefineResolution::description() const
{
    return tr("Affiner la résolution d'un raster");
}

QString ONF_StepRefineResolution::detailledDescription() const
{
    return tr("Cette étape crée, à partir d'un raster d'entrée, une copie calée sur l'emprise et la résolution d'un raster de référence."
              "Le rééchantillonnage est fait au plus proche voisin."
              "Cette étape est conçue pour que le raster cible est une résolution plus fine que celui d'entrée, idéalement un multiple.");
}

QString ONF_StepRefineResolution::inputDescription() const
{
    return SuperClass::inputDescription() + tr("<br><br>");
}

QString ONF_StepRefineResolution::outputDescription() const
{
    return SuperClass::outputDescription() + tr("<br><br>");
}

QString ONF_StepRefineResolution::detailsDescription() const
{
    return tr("");
}

CT_VirtualAbstractStep* ONF_StepRefineResolution::createNewInstance() const
{
    // cree une copie de cette etape
    return new ONF_StepRefineResolution();
}

/////////////////////// PROTECTED ///////////////////////

void ONF_StepRefineResolution::declareInputModels(CT_StepInModelStructureManager& manager)
{
    manager.addResult(_inResult, tr("Raster d'entrée"));
    manager.setZeroOrMoreRootGroup(_inResult, _inZeroOrMoreRootGroup);
    manager.addGroup(_inZeroOrMoreRootGroup, _inGroup);

    if (_rasterType == "none")
    {
        manager.addItem(_inGroup, _inRasterAbstract, tr("Raster d'entrée"));
    } else if (_rasterType == "float")
    {
        manager.addItem(_inGroup, _inRasterFloat, tr("Raster d'entrée"));
    } else if (_rasterType == "double")
    {
        manager.addItem(_inGroup, _inRasterDouble, tr("Raster d'entrée"));
    } else if (_rasterType == "quint8")
    {
        manager.addItem(_inGroup, _inRasterQuint8, tr("Raster d'entrée"));
    } else if (_rasterType == "qint8")
    {
        manager.addItem(_inGroup, _inRasterQint8, tr("Raster d'entrée"));
    } else if (_rasterType == "qint16")
    {
        manager.addItem(_inGroup, _inRasterQint16, tr("Raster d'entrée"));
    } else if (_rasterType == "qint32")
    {
        manager.addItem(_inGroup, _inRasterQint32, tr("Raster d'entrée"));
    } else if (_rasterType == "int")
    {
        manager.addItem(_inGroup, _inRasterInt, tr("Raster d'entrée"));
    }


    manager.addResult(_inResultRef, tr("Raster de référence"));
    manager.setZeroOrMoreRootGroup(_inResultRef, _inZeroOrMoreRootGroupRef);
    manager.addGroup(_inZeroOrMoreRootGroupRef, _inGroupRef);
    manager.addItem(_inGroupRef, _inRefRaster, tr("Raster de référence"));
}

void ONF_StepRefineResolution::declareOutputModels(CT_StepOutModelStructureManager& manager)
{    
    manager.addResultCopy(_inResultRef);

    if (_rasterType == "float")
    {
        manager.addItem(_inGroupRef, _outRasterFloat, _name);

    } else if (_rasterType == "double")
    {
        manager.addItem(_inGroupRef, _outRasterDouble, _name);

    } else if (_rasterType == "quint8")
    {
        manager.addItem(_inGroupRef, _outRasterQuint8, _name);

    } else if (_rasterType == "qint8")
    {
        manager.addItem(_inGroupRef, _outRasterQint8, _name);

    } else if (_rasterType == "qint16")
    {
        manager.addItem(_inGroupRef, _outRasterQint16, _name);

    } else if (_rasterType == "qint32")
    {
        manager.addItem(_inGroupRef, _outRasterQint32, _name);

    } else if (_rasterType == "int")
    {
        manager.addItem(_inGroupRef, _outRasterInt, _name);

    }
}

void ONF_StepRefineResolution::fillPreInputConfigurationDialog(CT_StepConfigurableDialog* preInputConfigDialog)
{
    QStringList types;
    types.append("float");
    types.append("double");
    types.append("quint8");
    types.append("qint8");
    types.append("qint16");
    types.append("qint32");
    types.append("int");

    if (_rasterType == "none") {_rasterType = "float";}

    preInputConfigDialog->addStringChoice(tr("Type de raster"), "", types, _rasterType);
}


void ONF_StepRefineResolution::fillPostInputConfigurationDialog(CT_StepConfigurableDialog* postInputConfigDialog)
{
    if (_rasterType == "float" && _inRasterFloat.hasAtLeastOnePossibilitySelected(_inResult))
    {
        _name = tr("%1 refined").arg(_inRasterFloat.outModelSelected(_inResult)->displayableName());
    }
    else if (_rasterType == "double" && _inRasterDouble.hasAtLeastOnePossibilitySelected(_inResult))
    {
        _name = tr("%1 refined").arg(_inRasterDouble.outModelSelected(_inResult)->displayableName());
    }
    else if (_rasterType == "quint8" && _inRasterQuint8.hasAtLeastOnePossibilitySelected(_inResult))
    {
        _name = tr("%1 refined").arg(_inRasterQuint8.outModelSelected(_inResult)->displayableName());
    }
    else if (_rasterType == "qint8" && _inRasterQint8.hasAtLeastOnePossibilitySelected(_inResult))
    {
        _name = tr("%1 refined").arg(_inRasterQint8.outModelSelected(_inResult)->displayableName());
    }
    else if (_rasterType == "qint16" && _inRasterQint16.hasAtLeastOnePossibilitySelected(_inResult))
    {
        _name = tr("%1 refined").arg(_inRasterQint16.outModelSelected(_inResult)->displayableName());
    }
    else if (_rasterType == "qint32" && _inRasterQint32.hasAtLeastOnePossibilitySelected(_inResult))
    {
        _name = tr("%1 refined").arg(_inRasterQint32.outModelSelected(_inResult)->displayableName());
    }
    else if (_rasterType == "int" && _inRasterInt.hasAtLeastOnePossibilitySelected(_inResult))
    {
        _name = tr("%1 refined").arg(_inRasterInt.outModelSelected(_inResult)->displayableName());
    }

    postInputConfigDialog->addString(tr("Nom à donner au raster"), "", _name, tr("<strong>Attention</strong> : ce paramètre ne peut être pris en compte qu'à l'ajout de l'étape ou au chargement d'un script.<br>Une modification de ce paramètre lors d'une reconfiguration des paramètres se répercutera dans les scripts exportés ultérieurement, <strong>mais pas dans la session en cours</strong>. "));
}


void ONF_StepRefineResolution::compute()
{

    for (CT_StandardItemGroup* group : _inGroupRef.iterateOutputs(_inResultRef))
    {
        for (const CT_AbstractImage2D* refRaster : group->singularItems(_inRefRaster))
        {
            if (isStopped()) {return;}

            qDebug() << "_rasterType=" << _rasterType;

            if (_rasterType == "float")
            {
                const CT_Image2D<float>* inRasterProto = _inRasterFloat.firstInput(_inResult);

                if (inRasterProto != nullptr)
                {
                    CT_Image2D<float>* outRaster = new CT_Image2D<float>(refRaster->minX(), refRaster->minY(), refRaster->xdim(), refRaster->ydim(), refRaster->resolution(), refRaster->minZ(), inRasterProto->NA(), inRasterProto->NA());

                    for (size_t n = 0 ; n < outRaster->nCells() ; n++)
                    {
                        Eigen::Vector3d center;
                        outRaster->getCellCenterCoordinates(n, center);

                        for (const CT_Image2D<float>* inRaster : _inRasterFloat.iterateInputs(_inResult))
                        {
                            float value = inRaster->valueAtCoords(center(0), center(1));

                            if (!qFuzzyCompare(value, inRaster->NA()))
                            {
                                outRaster->setValueAtIndex(n, value);
                                break;
                            }
                        }
                    }
                    group->addSingularItem(_outRasterFloat, outRaster);
                    outRaster->computeMinMax();
                }

            } else if (_rasterType == "double")
            {
                const CT_Image2D<double>* inRasterProto = _inRasterDouble.firstInput(_inResult);

                if (inRasterProto != nullptr)
                {
                    CT_Image2D<double>* outRaster = new CT_Image2D<double>(refRaster->minX(), refRaster->minY(), refRaster->xdim(), refRaster->ydim(), refRaster->resolution(), refRaster->minZ(), inRasterProto->NA(), inRasterProto->NA());

                    for (size_t n = 0 ; n < outRaster->nCells() ; n++)
                    {
                        Eigen::Vector3d center;
                        outRaster->getCellCenterCoordinates(n, center);

                        for (const CT_Image2D<double>* inRaster : _inRasterDouble.iterateInputs(_inResult))
                        {
                            double value = inRaster->valueAtCoords(center(0), center(1));

                            if (!qFuzzyCompare(value, inRaster->NA()))
                            {
                                outRaster->setValueAtIndex(n, value);
                                break;
                            }
                        }
                    }
                    group->addSingularItem(_outRasterDouble, outRaster);
                    outRaster->computeMinMax();
                }

            } else if (_rasterType == "quint8")
            {
                const CT_Image2D<quint8>* inRasterProto = _inRasterQuint8.firstInput(_inResult);

                if (inRasterProto != nullptr)
                {
                    CT_Image2D<quint8>* outRaster = new CT_Image2D<quint8>(refRaster->minX(), refRaster->minY(), refRaster->xdim(), refRaster->ydim(), refRaster->resolution(), refRaster->minZ(), inRasterProto->NA(), inRasterProto->NA());

                    for (size_t n = 0 ; n < outRaster->nCells() ; n++)
                    {
                        Eigen::Vector3d center;
                        outRaster->getCellCenterCoordinates(n, center);

                        for (const CT_Image2D<quint8>* inRaster : _inRasterQuint8.iterateInputs(_inResult))
                        {
                            quint8 value = inRaster->valueAtCoords(center(0), center(1));

                            if (value != inRaster->NA())
                            {
                                outRaster->setValueAtIndex(n, value);
                                break;
                            }
                        }
                    }

                    group->addSingularItem(_outRasterQuint8, outRaster);
                    outRaster->computeMinMax();
                }
            } else if (_rasterType == "qint8")
            {
                const CT_Image2D<qint8>* inRasterProto = _inRasterQint8.firstInput(_inResult);

                if (inRasterProto != nullptr)
                {
                    CT_Image2D<qint8>* outRaster = new CT_Image2D<qint8>(refRaster->minX(), refRaster->minY(), refRaster->xdim(), refRaster->ydim(), refRaster->resolution(), refRaster->minZ(), inRasterProto->NA(), inRasterProto->NA());

                    for (size_t n = 0 ; n < outRaster->nCells() ; n++)
                    {
                        Eigen::Vector3d center;
                        outRaster->getCellCenterCoordinates(n, center);

                        for (const CT_Image2D<qint8>* inRaster : _inRasterQint8.iterateInputs(_inResult))
                        {
                            qint8 value = inRaster->valueAtCoords(center(0), center(1));

                            if (value != inRaster->NA())
                            {
                                outRaster->setValueAtIndex(n, value);
                                break;
                            }
                        }
                    }

                    group->addSingularItem(_outRasterQint8, outRaster);
                    outRaster->computeMinMax();
                }
            } else if (_rasterType == "qint16")
            {
                const CT_Image2D<qint16>* inRasterProto = _inRasterQint16.firstInput(_inResult);

                if (inRasterProto != nullptr)
                {
                    CT_Image2D<qint16>* outRaster = new CT_Image2D<qint16>(refRaster->minX(), refRaster->minY(), refRaster->xdim(), refRaster->ydim(), refRaster->resolution(), refRaster->minZ(), inRasterProto->NA(), inRasterProto->NA());

                    for (size_t n = 0 ; n < outRaster->nCells() ; n++)
                    {
                        Eigen::Vector3d center;
                        outRaster->getCellCenterCoordinates(n, center);

                        for (const CT_Image2D<qint16>* inRaster : _inRasterQint16.iterateInputs(_inResult))
                        {
                            qint16 value = inRaster->valueAtCoords(center(0), center(1));

                            if (value != inRaster->NA())
                            {
                                outRaster->setValueAtIndex(n, value);
                                break;
                            }
                        }
                    }

                    group->addSingularItem(_outRasterQint16, outRaster);
                    outRaster->computeMinMax();
                }
            } else if (_rasterType == "qint32")
            {
                const CT_Image2D<qint32>* inRasterProto = _inRasterQint32.firstInput(_inResult);

                if (inRasterProto != nullptr)
                {
                    CT_Image2D<qint32>* outRaster = new CT_Image2D<qint32>(refRaster->minX(), refRaster->minY(), refRaster->xdim(), refRaster->ydim(), refRaster->resolution(), refRaster->minZ(), inRasterProto->NA(), inRasterProto->NA());

                    for (size_t n = 0 ; n < outRaster->nCells() ; n++)
                    {
                        Eigen::Vector3d center;
                        outRaster->getCellCenterCoordinates(n, center);

                        for (const CT_Image2D<qint32>* inRaster : _inRasterQint32.iterateInputs(_inResult))
                        {
                            qint32 value = inRaster->valueAtCoords(center(0), center(1));

                            if (value != inRaster->NA())
                            {
                                outRaster->setValueAtIndex(n, value);
                                break;
                            }
                        }
                    }

                    group->addSingularItem(_outRasterQint32, outRaster);
                    outRaster->computeMinMax();
                }
            } else if (_rasterType == "int")
            {
                const CT_Image2D<int>* inRasterProto = _inRasterInt.firstInput(_inResult);

                if (inRasterProto != nullptr)
                {
                    CT_Image2D<int>* outRaster = new CT_Image2D<int>(refRaster->minX(), refRaster->minY(), refRaster->xdim(), refRaster->ydim(), refRaster->resolution(), refRaster->minZ(), inRasterProto->NA(), inRasterProto->NA());

                    for (size_t n = 0 ; n < outRaster->nCells() ; n++)
                    {
                        Eigen::Vector3d center;
                        outRaster->getCellCenterCoordinates(n, center);

                        for (const CT_Image2D<int>* inRaster : _inRasterInt.iterateInputs(_inResult))
                        {
                            int value = inRaster->valueAtCoords(center(0), center(1));

                            if (value != inRaster->NA())
                            {
                                outRaster->setValueAtIndex(n, value);
                                break;
                            }
                        }
                    }

                    group->addSingularItem(_outRasterInt, outRaster);
                    outRaster->computeMinMax();
                }
            }
        }
        setProgress(100.0f);
    }
}