TerrainFilters.h

#pragma once

namespace ParaEngine
{
    class TTerrain;
    

    class CTerrainFilters
    {
    public:
        CTerrainFilters(void);
        ~CTerrainFilters(void);

        enum MergeOperation{
            Addition=0,
            Subtract,
            Multiplication,
            Division,
            Minimum,
            Maximum
        };
        enum FlattenOperation{
            Fill_Op,
            ShaveTop_Op,
            Flatten_Op
        };
    public:
        TTerrain* GetTerrainData();

        void Flatten (FlattenOperation flatten_op, float elevation,float factor, float center_x,    float center_y, float radius);
        void RadialScale (float center_x, float center_y, float scale_factor, float min_dist,float max_dist, float smooth_factor, int frequency);

        /*
        *  This creates a Gaussian hill at the specified location with the specified parameters.
        *  it actually adds the hill to the original terrain surface.
        *  Here ElevNew(x,y) = 
                |(x,y)-(center_x,center_y)| < radius*smooth_factor, ElevOld(x,y)+hscale*exp(-[(x-center_x)^2+(y-center_y)^2]/(2*standard_deviation^2) ),
                |(x,y)-(center_x,center_y)| > radius*smooth_factor, minimize hill effect.
        * @param center_x: the center of the affected circle. value in the range [0,1]
        * @param center_y: the center of the affected circle.value in the range [0,1]
        * @param radius: the radius of the affected circle.value in the range [0,0.5]
        * @param hscale: scale factor. One can think of it as the maximum height of the Gaussian Hill. this value can be negative
        * @param standard_deviation: standard deviation of the unit height value. should be in the range (0,1). 
        *  0.1 is common value. larger than that will just make a flat hill with smoothing.
        * @param smooth_factor: value is between [0,1]. 1 means fully transformed; 0 means nothing is changed
        */
        void GaussianHill (float x,float y,float radius,float hscale,float standard_deviation,float smooth_factor);

        void Spherical ( float    offset);
        /* 
        * return the sum of the neighboring cells in a square size with 
        * sides 1+(size*2) long
        */
        static float grid_neighbour_sum_size(TTerrain*terrain,int x, int y,int size);
        /* 
        * return the average of the neighboring cells in a square size with 
        * sides 1+(size*2) long
        */
        static float grid_neighbour_average_size(TTerrain*terrain,
            int      x, 
            int      y,
            int      size);
        void Roughen_Smooth (bool roughen, bool big_grid,float factor);

        void Ramp(float x1, float y1, float height1, float x2, float y2, float height2, float radius, float borderpercentage=0.5f, float factor=1.0f);
        
        void SetConstEdgeHeight(float fHeight=0, int nSmoothPixels=7);

        void Merge (TTerrain *terrain_1,
            TTerrain *terrain_2,
            float    weight_1,
            float    weight_2,
            MergeOperation      operation);

    private:
        TTerrain* m_pTerrainData;
    };
}