Grid.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or
having been advised so by Algoryx Simulation AB for a time limited evaluation,
or having purchased a valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
 
#pragma once
 
#include <tuple>
 
#include <agxTerrain/export.h>
#include <agxCollide/Mesh.h>
#include <agx/IndexLambdaKernel.h>
 
#include <mutex>
 
#include <agxTerrain/export.h>
 
#include <agx/AffineMatrix4x4.h>
#include <agx/Plane.h>
#include <agx/Line.h>
 
#include <agxCollide/HeightField.h>
#include <agxCollide/BoundingAABB.h>
#include <agxCollide/Convex.h>
 
#include <agxStream/InputArchive.h>
#include <agxStream/OutputArchive.h>
 
#include <agxTerrain/VoxelGridUtils.h>
 
namespace agxTerrain
{
  // Container for defining a height in terms of which voxel level and how filled the voxel is.
  struct GridElement
  {
      int z = 0;
      float occupancy = 0.0f;
  };
 
  // Container struct for containing data regarding removed volume
  struct ActiveZoneIntersectionData
  {
    agx::Bound3i indicesInActiveZone;
    agx::Vec3iVector removedIndices;
    agx::Real32Vector removedOccupancy;
    agx::Real removedVolume;
  };
 
  typedef std::tuple<const agxCollide::Mesh*, agx::AffineMatrix4x4, agxCollide::BoundingAABB> MeshIntersectionTestData;
  typedef std::tuple<const agxCollide::Shape*, agx::AffineMatrix4x4, agxCollide::BoundingAABB> ShapeIntersectionTestData;
  typedef agx::Vector<MeshIntersectionTestData> ActiveZoneShapes;
  typedef agx::Vector<std::array<agx::Vec3, 3>> TriangleVector;
 
 
  AGX_DECLARE_POINTER_TYPES(BasicGrid);
  AGX_DECLARE_POINTER_TYPES(Grid);
 
  class AGXTERRAIN_EXPORT BasicGrid : public agx::Referenced, public agxStream::Serializable
  {
    public:
 
      using GridCoord = agx::Vec3i;
 
      using GridCoordVector = agx::VectorPOD<GridCoord>;
 
      using GridFunction = std::function<void(GridCoord, float)>;
 
 
    public:
      virtual agx::Vec3 getElementSize() const = 0;
 
      virtual size_t getMemoryUsage() const = 0;
 
      virtual bool empty() = 0;
 
      virtual void clearGrid() = 0;
 
      virtual void setFloatValue(const GridCoord& ijk, float value) = 0;
 
      virtual float getFloatValue(const GridCoord& ijk) const = 0;
 
      virtual bool isActiveVoxel(const GridCoord& /*ijk*/) const = 0;
 
      virtual size_t getNumActiveVoxels() const = 0;
 
      virtual agx::Real getTotal() const = 0;
 
      virtual std::tuple<float, float> getTotalAndLargest() const = 0;
 
      virtual GridCoordVector getActiveVoxelIndices() const = 0;
 
      virtual void sizeHint( size_t /*hint*/ ) {}
 
      /*
      \return true if the implementation supports iterateVoxels
      */
      virtual bool hasIterateSupport() const { return false; }
 
      /*
      Implementation dependent method that iterates over all voxels in some order
      and calls func( voxel_ijk, voxel_value) for each voxel.
 
      It is not valid to have the function change the grid while iterating.
      */
      virtual void iterateVoxels( GridFunction /*func*/ ) const {}
 
 
      virtual agx::HashSet<agx::Vec3i> findGeometryVoxelIntersections(const agx::AffineMatrix4x4& gridTransform,
                                                                      const agxCollide::Geometry* geometry,
                                                                      agx::Real voxelSize,
                                                                      bool onlyOccupiedVoxels = true,
                                                                      bool onlyMidPoint = false ) const = 0;
 
 
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( agxTerrain::BasicGrid );
      void store( agxStream::OutputArchive& out ) const override = 0;
      void restore( agxStream::InputArchive& in ) override = 0;
 
 
  protected:
    /*
    Get the center position of the specified voxel in voxel space coordinates.
    \param voxelIndex - agx::Vec3i with x and y >= 0.
    */
    inline agx::Vec3 getGridPositionFromVoxelIndex(const agx::Vec3i& voxelIndex) const
    {
      return VoxelGridUtils::getGridPositionFromVoxelIndex(voxelIndex, getElementSize().x());
    }
 
    /*
    Get the voxel index from a voxel space position in the grid.
    \param position - voxel space position
    */
    inline agx::Vec3i getVoxelIndexFromGridPosition(agx::Vec3 position) const
    {
      return VoxelGridUtils::getVoxelIndexFromGridPosition(position, getElementSize().x());
    }
  };
 
 
  class AGXTERRAIN_EXPORT Grid : public BasicGrid
  {
 
  public:
 
 
 
    virtual agxCollide::BoundingAABB getBoundingBox() const = 0;
 
 
    virtual void setValuesBelowHeightField(
      const agxCollide::HeightField* heightField,
      agx::Real voxelSize,
      int lowestAllowedVoxelIndex,
      BasicGrid* compactionGrid) = 0;
 
 
    virtual agx::HashSet<agx::Vec3i> findConvexVoxelIntersections(const agx::AffineMatrix4x4& gridTransform,
      const agxCollide::Convex* convex,
      agx::Real voxelSize) = 0;
 
 
    virtual bool findMeshVoxelIntersections(const agx::AffineMatrix4x4& gridTransform,
      const agxCollide::Mesh* mesh,
      agx::Real voxelSize,
      agx::Vec3iVector& result) = 0;
 
 
 
    virtual agx::HashSet<agx::Vec3i> findVoxelsAboveTriangles(
      const agx::AffineMatrix4x4& gridTransform,
      const TriangleVector& triangles,
      agx::Real voxelSize,
      agx::Real margin) = 0;
 
 
 
    virtual ActiveZoneIntersectionData removeVolumeInActiveZone(
      const agx::AffineMatrix4x4& gridTransformation,
      const ActiveZoneShapes& activeZoneShapes,
      const ActiveZoneShapes& innerShape,
      const agx::Plane& innerShapeBoundary,
      const agx::Bound3& activeZoneGeometryBound,
      const agx::Vec3iVector voxelsInPrimaryActiveZoneLastTimeStep,
      std::function<float(const agx::Vec3i&)> getCompression,
      std::function<bool(const agx::Vec2i&)> canRemoveIndex,
      agx::Real voxelSize,
      agx::Real minOccupancyRemoval,
      std::function<agx::Real(const agx::Vec2i&)> getMinAllowedHeight,
      bool useParticleFreeDeformers) = 0;
 
 
 
    virtual ActiveZoneIntersectionData removeVolumeInShape( const agx::AffineMatrix4x4& gridTransformation,
                                                            const ShapeIntersectionTestData& shape,
                                                            std::function<float( const agx::Vec3i& )> getCompression,
                                                            std::function<bool( const agx::Vec2i& )> canRemoveIndex,
                                                            std::function<bool( const agx::Vec3&, const agx::Vec3i& )> isWithinBoundry,
                                                            agx::Real voxelSize,
                                                            agx::Real minOccupancyRemoval,
                                                            std::function<agx::Real(const agx::Vec2i&)> getMinAllowedHeight) = 0;
 
    virtual agx::Vec3iVector findVoxelsInLine( const agx::Line& gridLine ) const = 0;
 
    virtual void findVoxelSurfaceFromIndex( const agx::Vec3i& index, agx::Vec3i& result ) = 0;
 
    AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( agxTerrain::Grid );
  };
 
 
 
}