/******************************************************************************
 * $Id: gdalpansharpen.h 8ca42e1b9c2e54b75d35e49885df9789a2643aa4 2020-05-17 21:43:40 +0200 Even Rouault $
 *
 * Project:  GDAL Pansharpening module
 * Purpose:  Prototypes, and definitions for pansharpening related work.
 * Author:   Even Rouault <even.rouault at spatialys.com>
 *
 ******************************************************************************
 * Copyright (c) 2015, Even Rouault <even.rouault at spatialys.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/

#ifndef GDALPANSHARPEN_H_INCLUDED
#define GDALPANSHARPEN_H_INCLUDED

#include "gdal.h"

CPL_C_START

/**
 * \file gdalpansharpen.h
 *
 * GDAL pansharpening related entry points and definitions.
 *
 * @since GDAL 2.1
 */

/** Pansharpening algorithms.
 */
typedef enum
{
    /*! Weighted Brovery. */
    GDAL_PSH_WEIGHTED_BROVEY
} GDALPansharpenAlg;

/** Pansharpening options.
  */
typedef struct
{
    /*! Pan sharpening algorithm/method. Only weighed Brovey for now. */
    GDALPansharpenAlg    ePansharpenAlg;

    /*! Resampling algorithm to upsample spectral bands to pan band resolution. */
    GDALRIOResampleAlg   eResampleAlg;

    /*! Bit depth of the spectral bands. Can be let to 0 for default behavior. */
    int                  nBitDepth;

    /*! Number of weight coefficients in padfWeights. */
    int                  nWeightCount;

    /*! Array of nWeightCount weights used by weighted Brovey. */
    double              *padfWeights;

    /*! Panchromatic band. */
    GDALRasterBandH      hPanchroBand;

    /*! Number of input spectral bands. */
    int                  nInputSpectralBands;

    /** Array of nInputSpectralBands input spectral bands. The spectral band have
     *  generally a coarser resolution than the panchromatic band, but they
     *  are assumed to have the same spatial extent (and projection) at that point.
     *  Necessary spatial adjustments must be done beforehand, for example by wrapping
     *  inside a VRT dataset.
     */
    GDALRasterBandH     *pahInputSpectralBands;

    /*! Number of output pansharpened spectral bands. */
    int                  nOutPansharpenedBands;

    /*! Array of nOutPansharpendBands values such as panOutPansharpenedBands[k] is a value in the range [0,nInputSpectralBands-1] . */
    int                 *panOutPansharpenedBands;

    /*! Whether the panchromatic and spectral bands have a noData value. */
    int                  bHasNoData;

    /** NoData value of the panchromatic and spectral bands (only taken into account if bHasNoData = TRUE).
        This will also be use has the output nodata value. */
    double               dfNoData;

    /** Number of threads or -1 to mean ALL_CPUS. By default (0), single threaded mode is enabled
      * unless the GDAL_NUM_THREADS configuration option is set to an integer or ALL_CPUS. */
    int                  nThreads;

    /** Shift in pixels of multispectral bands w.r.t panchromatic band, in X direction */
    double               dfMSShiftX;

    /** Shift in pixels of multispectral bands w.r.t panchromatic band, in Y direction */
    double               dfMSShiftY;

} GDALPansharpenOptions;

GDALPansharpenOptions CPL_DLL * GDALCreatePansharpenOptions(void);
void CPL_DLL GDALDestroyPansharpenOptions( GDALPansharpenOptions * );
GDALPansharpenOptions CPL_DLL * GDALClonePansharpenOptions(
                                        const GDALPansharpenOptions* psOptions);

/*! Pansharpening operation handle. */
typedef void* GDALPansharpenOperationH;

GDALPansharpenOperationH CPL_DLL GDALCreatePansharpenOperation(const GDALPansharpenOptions* );
void CPL_DLL GDALDestroyPansharpenOperation( GDALPansharpenOperationH );
CPLErr CPL_DLL GDALPansharpenProcessRegion( GDALPansharpenOperationH hOperation,
                                            int nXOff, int nYOff,
                                            int nXSize, int nYSize,
                                            void *pDataBuf,
                                            GDALDataType eBufDataType);

CPL_C_END

#ifdef __cplusplus

#include <vector>
#include "gdal_priv.h"
#include "cpl_worker_thread_pool.h"

#ifdef DEBUG_TIMING
#include <sys/time.h>
#endif

class GDALPansharpenOperation;

//! @cond Doxygen_Suppress
typedef struct
{
    GDALPansharpenOperation* poPansharpenOperation;
    GDALDataType eWorkDataType;
    GDALDataType eBufDataType;
    const void* pPanBuffer;
    const void* pUpsampledSpectralBuffer;
    void* pDataBuf;
    size_t nValues;
    size_t nBandValues;
    GUInt32 nMaxValue;

#ifdef DEBUG_TIMING
    struct timeval* ptv;
#endif

    CPLErr eErr;
} GDALPansharpenJob;

typedef struct
{
    GDALDataset* poMEMDS;
    int          nXOff;
    int          nYOff;
    int          nXSize;
    int          nYSize;
    double       dfXOff;
    double       dfYOff;
    double       dfXSize;
    double       dfYSize;
    void        *pBuffer;
    GDALDataType eDT;
    int          nBufXSize;
    int          nBufYSize;
    int          nBandCount;
    GDALRIOResampleAlg eResampleAlg;
    GSpacing     nBandSpace;

#ifdef DEBUG_TIMING
    struct timeval* ptv;
#endif
} GDALPansharpenResampleJob;
//! @endcond

/** Pansharpening operation class.
 */
class GDALPansharpenOperation
{
        CPL_DISALLOW_COPY_ASSIGN(GDALPansharpenOperation)

        GDALPansharpenOptions* psOptions = nullptr;
        std::vector<int> anInputBands{};
        std::vector<GDALDataset*> aVDS{}; // to destroy
        std::vector<GDALRasterBand*> aMSBands{}; // original multispectral bands potentially warped into a VRT
        int bPositiveWeights = TRUE;
        CPLWorkerThreadPool* poThreadPool = nullptr;
        int nKernelRadius = 0;

        static void PansharpenJobThreadFunc(void* pUserData);
        static void PansharpenResampleJobThreadFunc(void* pUserData);

        template<class WorkDataType, class OutDataType> void WeightedBroveyWithNoData(
                                                     const WorkDataType* pPanBuffer,
                                                     const WorkDataType* pUpsampledSpectralBuffer,
                                                     OutDataType* pDataBuf,
                                                     size_t nValues,
                                                     size_t nBandValues,
                                                     WorkDataType nMaxValue) const;
        template<class WorkDataType, class OutDataType, int bHasBitDepth> void WeightedBrovey3(
                                                     const WorkDataType* pPanBuffer,
                                                     const WorkDataType* pUpsampledSpectralBuffer,
                                                     OutDataType* pDataBuf,
                                                     size_t nValues,
                                                     size_t nBandValues,
                                                     WorkDataType nMaxValue) const;

        // cppcheck-suppress functionStatic
        template<class WorkDataType, class OutDataType> void WeightedBrovey(
                                                     const WorkDataType* pPanBuffer,
                                                     const WorkDataType* pUpsampledSpectralBuffer,
                                                     OutDataType* pDataBuf,
                                                     size_t nValues,
                                                     size_t nBandValues,
                                                     WorkDataType nMaxValue) const;
        template<class WorkDataType> CPLErr WeightedBrovey(
                                                     const WorkDataType* pPanBuffer,
                                                     const WorkDataType* pUpsampledSpectralBuffer,
                                                     void *pDataBuf,
                                                     GDALDataType eBufDataType,
                                                     size_t nValues,
                                                     size_t nBandValues,
                                                     WorkDataType nMaxValue) const;

        // cppcheck-suppress functionStatic
        template<class WorkDataType> CPLErr WeightedBrovey(
                                                     const WorkDataType* pPanBuffer,
                                                     const WorkDataType* pUpsampledSpectralBuffer,
                                                     void *pDataBuf,
                                                     GDALDataType eBufDataType,
                                                     size_t nValues,
                                                     size_t nBandValues) const;
        template<class T> void WeightedBroveyPositiveWeights(
                                                     const T* pPanBuffer,
                                                     const T* pUpsampledSpectralBuffer,
                                                     T* pDataBuf,
                                                     size_t nValues,
                                                     size_t nBandValues,
                                                     T nMaxValue) const;

        template<class T, int NINPUT, int NOUTPUT> size_t WeightedBroveyPositiveWeightsInternal(
                                                     const T* pPanBuffer,
                                                     const T* pUpsampledSpectralBuffer,
                                                     T* pDataBuf,
                                                     size_t nValues,
                                                     size_t nBandValues,
                                                     T nMaxValue) const;

        // cppcheck-suppress unusedPrivateFunction
        template<class T> void WeightedBroveyGByteOrUInt16(
                                                     const T* pPanBuffer,
                                                     const T* pUpsampledSpectralBuffer,
                                                     T* pDataBuf,
                                                     size_t nValues,
                                                     size_t nBandValues,
                                                     T nMaxValue ) const;

        // cppcheck-suppress functionStatic
        CPLErr PansharpenChunk( GDALDataType eWorkDataType, GDALDataType eBufDataType,
                                                     const void* pPanBuffer,
                                                     const void* pUpsampledSpectralBuffer,
                                                     void* pDataBuf,
                                                     size_t nValues,
                                                     size_t nBandValues,
                                                     GUInt32 nMaxValue) const;
    public:
                             GDALPansharpenOperation();
                            ~GDALPansharpenOperation();

        CPLErr               Initialize(const GDALPansharpenOptions* psOptions);
        CPLErr               ProcessRegion(int nXOff, int nYOff,
                                           int nXSize, int nYSize,
                                           void *pDataBuf,
                                           GDALDataType eBufDataType);
        GDALPansharpenOptions* GetOptions();
};

#endif /* __cplusplus */

#endif /* GDALPANSHARPEN_H_INCLUDED */
