ComputeNormals.cpp

#include <bone/FishSlice.hpp>
#include <bone/FishGrid.hpp>
#include <bone/FishField.hpp>
 
#include <grid/types/TriangularSurface.hpp>
 
namespace
{
 
using namespace Wizt;
using namespace Fiber;
using namespace Eagle;
 
class   VComputeNormals : public virtual VObject,
                          public virtual Fish<Fiber::Slice>,
                          public virtual Fish<Fiber::Grid>
{
public:
        VOutput<Fiber::Field>   theNormalVectorField;
 
        
        BundleSlot myBundle() const
        {
                return TypedSlot<Fiber::BundlePtr>();
        }
 
        VComputeNormals(const string&name, int p, const RefPtr<VCreationPreferences>&VP)
        : VObject(name, p, VP)
        , theNormalVectorField( self(), "Normals")
        {
                theNormalVectorField.provides<PhysicalSpace::bivector>(); 
        }
 
        bool update(VRequest&R, double precision) override;
};
 
 
bool    VComputeNormals::update(VRequest&Context, double precision)
{
 
Info<Grid> iG = findMostRecentGrid( Context ); 
 
 
RefPtr<Grid>  G = iG;
        if (!G)
        {
                printf("ComputeNormals: update(): No grid!\n"); 
                return true;
        }
RefPtr<Field> NormalsField = (*G)( TriangularSurface::NormalVectorFieldName ); 
        if (NormalsField)
        {
                puts("already have normals"); 
                return true;
        }
 
RefPtr<Field> Coords  = G->CartesianPositions();
        if (!Coords)  
        {
                puts("No coord field!");
                return true; 
        }
RefPtr<Representation> CellsAsVertices = G->CellsAsVertices(2); 
        if (!CellsAsVertices)
        {
                puts("VComputeNormals: No cells as vertices found"); 
                return true;
        } 
 
RefPtr<TriangularSurface::NormalVectorArray_t>
        VertexNormals =
        TriangularSurface::computeVertexNormals(
                Coords->getData(),
                CellsAsVertices->getPositions()->getData()
                );
 
        (*G)[ TriangularSurface::NormalVectorFieldName ] = new Field( VertexNormals ); 
 
FieldSelector FS( getGridSelector(Context), iG); 
 
        FS.selectTypedField<PhysicalSpace::bivector>( TriangularSurface::NormalVectorFieldName );
        
        theNormalVectorField << Context << FS;
        return true;
}
 
}
 
namespace
{
using namespace Panthalassa;
 
static VSink< Grid, VComputeNormals >
MyCreator(      Category( "Compute" ) + VIdentifier( "Normals" ) + Application( "General" ) +
                Description( "Compute normal vectors of a triangular surface." ) +
                Help( "todo" ) +
                Url( "http://vish.fiberbundle.net/wiki" ),
                ObjectQuality::EXPERIMENTAL );
}