/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 * 
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 

#ifndef H_OGF_SHAPENET_ALGOS_POISSON_H
#define H_OGF_SHAPENET_ALGOS_POISSON_H

#include <geogram/basic/common.h>
#include <geogram/basic/assert.h>
#include <geogram/basic/numeric.h>
#include <geogram/basic/geometry.h>

// Note: This file is not part of Kahzdan's original Poisson reconstruction
// code.

namespace GEO {

    class Mesh;
    
    /**
     * \brief A wrapper to interface Kahzdan's Poisson reconstruction
     *  with Geogram datastructures.
     */
    class GEOGRAM_API PoissonReconstruction {
    public:
        
        /**
         * \brief PoissonReconstruction constructor.
         */
        PoissonReconstruction();

        /***
         * \brief PoissonReconstruction destructor.
         */
        ~PoissonReconstruction();
        
        /**
         * \brief Reconstructs a surface.
         * \param[in] points a pointer to a Mesh with the points.
         *  It needs to have a vector attribute of dimension 3 
         *  called "normal" and attached to the vertices.
         * \param[out] surface the reconstructed surface
         */
        void reconstruct(Mesh* points, Mesh* surface);

        /**
         * \brief Sets the depth of the octree.
         * \param[in] x the new depth of the octree
         * \details Default value is 8. Use 10 or 11 for highly 
         *  detailed models.
         */
        void set_depth(index_t x) {
            depth_ = int(x);
        }

        /**
         * \brief Gets the depth of the octree.
         * \return the depth of the octree
         */
        index_t get_depth() const {
            return index_t(depth_);
        }

        /**
         * \brief Sets whether voxel data should be kept.
         * \param[in] x true if voxel data should be kept,
         *  false otherwise (default).
         */
        void set_keep_voxel(bool x) {
            keep_voxel_ = x;
        }

        /**
         * \brief Tests whether voxel data is kept.
         * \retval true if voxel data is kept
         * \retval false otherwise
         */
        bool get_keep_voxel() const {
            return keep_voxel_;
        }

        /**
         * \brief Gets the voxel values.
         * \details Can be called if set_keel_voxel(true) 
         *  was called before calling reconstruct().
         * \return a pointer to an array of 
         *  voxel_resolution() *  voxel_resolution() * voxel_resolution()
         *  floating point coordinates. PoissonReconstruction keeps ownership
         *  of the allocated memory.
         */
        float* voxel_values() const {
            geo_assert(keep_voxel_);
            return voxel_values_;
        }

        /**
         * \brief Gets the resolution of the created voxel grid.
         * \details Can be called if set_keel_voxel(true) 
         *  was called before calling reconstruct().
         * \return The resolution of the created voxel grid.
         */
        index_t voxel_resolution() const {
            geo_assert(keep_voxel_);            
            return voxel_res_;
        }

        /**
         * \brief Gets the origin of the box.
         * \return the corner of the box with the
         *  smallest x,y,z coordinates
         */
        const vec3& box_origin() const {
            return box_origin_;
        }

        /**
         * \brief Gets the edge length of the box.
         * \return the edge length of the box
         */
        double box_edge_length() const {
            return box_edge_length_;
        }
        
        // TODO: add setters and getters for the
        // other parameters (not all of them are
        // needed though)

    private:
        /**
         * \brief Forbids copy.
         */
        PoissonReconstruction(const PoissonReconstruction& rhs);
        
        /**
         * \brief Forbids copy.
         */
        PoissonReconstruction& operator=(const PoissonReconstruction& rhs);
        
    private:
        bool performance_;
        bool complete_;
        bool no_comments_;
        bool polygon_mesh_;
        bool confidence_;
        bool normal_weights_;
        bool non_manifold_;
        bool dirichlet_;
        bool ascii_;
        bool density_;
        bool linear_fit_;
        bool primal_voxel_;
        bool verbose_;
        
        int degree_;
        int depth_;
        int cg_depth_;
        int kernel_depth_;
        int adaptive_exponent_;
        int iters_;
        int voxel_depth_;
        int full_depth_;
        int min_depth_;
        int max_solve_depth_;
        int threads_;

        float color_;
        float samples_per_node_;
        float scale_;
        float cg_accuracy_;
        float point_weight_;

        bool keep_voxel_;
        index_t voxel_res_;
        float* voxel_values_;

        vec3 box_origin_;
        double box_edge_length_;
    };
    
}

#endif
