libigl_Martin/include/igl/boolean/BinaryWindingNumberOperations.h

// This file is part of libigl, a simple c++ geometry processing library.
// 
// Copyright (C) 2015 Qingnan Zhou <qnzhou@gmail.com>
// 
// This Source Code Form is subject to the terms of the Mozilla Public License 
// v. 2.0. If a copy of the MPL was not distributed with this file, You can 
// obtain one at http://mozilla.org/MPL/2.0/.
//
#ifndef IGL_BINARY_WINDING_NUMBER_OPERATIONS
#define IGL_BINARY_WINDING_NUMBER_OPERATIONS

#include <stdexcept>
#include <igl/igl_inline.h>
#include "MeshBooleanType.h"
#include <Eigen/Core>

namespace igl
{
    namespace boolean
    {
        template <igl::boolean::MeshBooleanType Op>
        class BinaryWindingNumberOperations {
            public:
                template<typename DerivedW>
                    typename DerivedW::Scalar operator()(
                            const Eigen::PlainObjectBase<DerivedW>& win_nums) const {
                        throw (std::runtime_error("not implemented!"));
                    }
        };

        template <>
        class BinaryWindingNumberOperations<igl::boolean::MESH_BOOLEAN_TYPE_UNION> {
            public:
                template<typename DerivedW>
                    typename DerivedW::Scalar operator()(
                            const Eigen::PlainObjectBase<DerivedW>& win_nums) const {
                        return win_nums(0) > 0 || win_nums(1) > 0;
                    }
        };

        template <>
        class BinaryWindingNumberOperations<igl::boolean::MESH_BOOLEAN_TYPE_INTERSECT> {
            public:
                template<typename DerivedW>
                    typename DerivedW::Scalar operator()(
                            const Eigen::PlainObjectBase<DerivedW>& win_nums) const {
                        return win_nums(0) > 0 && win_nums(1) > 0;
                    }
        };

        template <>
        class BinaryWindingNumberOperations<igl::boolean::MESH_BOOLEAN_TYPE_MINUS> {
            public:
                template<typename DerivedW>
                    typename DerivedW::Scalar operator()(
                            const Eigen::PlainObjectBase<DerivedW>& win_nums) const {
                        return win_nums(0) > 0 && win_nums(1) <= 0;
                    }
        };

        template <>
        class BinaryWindingNumberOperations<igl::boolean::MESH_BOOLEAN_TYPE_XOR> {
            public:
                template<typename DerivedW>
                    typename DerivedW::Scalar operator()(
                            const Eigen::PlainObjectBase<DerivedW>& win_nums) const {
                        return (win_nums(0) > 0 && win_nums(1) <= 0) ||
                            (win_nums(0) <= 0 && win_nums(1) > 0);
                    }
        };

        template <>
        class BinaryWindingNumberOperations<igl::boolean::MESH_BOOLEAN_TYPE_RESOLVE> {
            public:
                template<typename DerivedW>
                    typename DerivedW::Scalar operator()(
                            const Eigen::PlainObjectBase<DerivedW>& win_nums) const {
                        return true;
                    }
        };

        typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_UNION> BinaryUnion;
        typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_INTERSECT> BinaryIntersect;
        typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_MINUS> BinaryMinus;
        typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_XOR> BinaryXor;
        typedef BinaryWindingNumberOperations<MESH_BOOLEAN_TYPE_RESOLVE> BinaryResolve;

        enum KeeperType {
            KEEP_INSIDE,
            KEEP_ALL
        };

        template<KeeperType T>
        class WindingNumberFilter {
            public:
                template<typename DerivedW>
                    short operator()(
                            const Eigen::PlainObjectBase<DerivedW>& win_nums) const {
                        throw std::runtime_error("Not implemented");
                    }
        };

        template<>
        class WindingNumberFilter<KEEP_INSIDE> {
            public:
                template<typename T>
                    short operator()(T out_w, T in_w) const {
                        if (in_w > 0 && out_w <= 0) return 1;
                        else if (in_w <= 0 && out_w > 0) return -1;
                        else return 0;
                    }
        };

        template<>
        class WindingNumberFilter<KEEP_ALL> {
            public:
                template<typename T>
                    short operator()(T out_w, T in_w) const {
                        return 1;
                    }
        };

        typedef WindingNumberFilter<KEEP_INSIDE> KeepInside;
        typedef WindingNumberFilter<KEEP_ALL> KeepAll;
    }
}

#endif