Cloth.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
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.
 
Library: NDEVR
File: NDEVRPCH
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
/*
 * This source code is about a ground filtering algorithm for airborn LiDAR data
 * based on physical process simulations, specifically cloth simulation.
 *
 * this code is based on a Cloth Simulation Tutorial at the cg.alexandra.dk blog.
 * Thanks to Jesper Mosegaard (clothTutorial@jespermosegaard.dk)
 *
 *
 *
 * When applying the cloth simulation to LIDAR point filtering. A lot of features
 * have been added to the original source code, including
 * configuration file management
 * point cloud data read/write
 * point-to-point collsion detection
 * nearest point search structure from CGAL
 * addding a terrain class
 *
 *
 */
// using discrete steps (drop and pull) to approximate the physical process
 
#pragma once
#include "Particle.h"
#include "Base/Headers/Vertex.hpp"
#include "Base/Headers/BaseValues.hpp"
#include "Base/Headers/Buffer.hpp"
#include "Base/Headers/RGBColor.h"
// post processing is only for connected component which is large than 50
#define MAX_PARTICLE_FOR_POSTPROCESSIN    50
 
 
namespace NDEVR
{
    class Cloth
    {
    private:
 
        // total number of particles is num_particles_width * num_particles_height
        uint04 constraint_iterations;   
 
        fltp04 time_step;               
 
        Buffer<Particle> particles;     
 
        fltp04 smoothThreshold;         
        fltp04 heightThreshold;         
        Vector<3, fltp04> m_acceleration; 
        Buffer<RGBColor> m_colors;      
    public:
        Vertex<3, fltp04> origin_pos;   
        fltp04 step_x, step_y;          
        Buffer<fltp04> heightvals;      
        Vector<2, uint04> size;         
        Particle& getParticle(uint04 x, uint04 y) {
            return particles[y * size[X] + x];
        }
        const Particle& getParticle(uint04 x, uint04 y) const {
            return particles[y * size[X] + x];
        }
        const RGBColor& getColor(uint04 index)
        {
            return m_colors[index];
        }
        void setColor(uint04 index, RGBColor color)
        {
            m_colors[index] = color;
        }
        uint04 get1DIndex(uint04 x, uint04 y) const
        {
            return y * size[X] + x;
        }
        Vector<2, uint04> get2DIndex(uint04 index) const
        {
            return Vector<2, uint04>(index % size[X], index / size[X]);
        }
        Vector<3, fltp04> getNormalAt(const Vector<2, uint04>& index) const;
    public:
 
        uint04 getSize() {
            return size[X] * size[Y];
        }
 
 
        inline Buffer<fltp04>& getHeightvals() {
            return heightvals;
        }
 
        Particle& getParticle1d(uint04 index) {
            return particles[index];
        }
        [[nodiscard]] const Buffer<Particle>& getParticles() const
        {
            return particles;
        }
    public:
        Cloth(const Vector<3, fltp04>& origin_pos, const Vector<2, uint04>& size, const Vector<2, fltp04>& step, fltp04 smoothThreshold
            , fltp04 heightThreshold, uint04 rigidness, fltp04 time_step, bool use_colors);
        void adjustParticleByNeighbor(Particle& p1, Particle& p2);
 
        /* this is an important methods where the time is progressed one
         * time step for the entire cloth.  This includes calling
         * satisfyConstraint() for every constraint, and calling
         * timeStep() for all particles
         */
        void timeStep();
 
        /* used to add gravity (or any other arbitrary vector) to all
         * particles */
        void addForce(const Vector<3, fltp04> direction);
 
        void terrCollision();
 
        void movableFilter();
 
        void fillHoles();
        Buffer<uint04> findUnmovablePoint(Buffer<Vector<2, uint04>> connected);
 
        void handle_slop_connected(const Buffer<uint04>& edgePoints, const Buffer<Vector<2, uint04>>& connected, const Buffer<Buffer<uint04>>& neibors);
    };
 
 
}