Merge branch 'master' into 202601_lifecycle_attribute_disabled_1

Author: hugtalbot

CMakePresets.json

@@ -168,14 +168,6 @@
           "type": "BOOL",
           "value": "ON"
         },
-        "SOFA_FETCH_SOFAVISCOELASTIC": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "PLUGIN_SOFAVISCOELASTIC": {
-          "type": "BOOL",
-          "value": "ON"
-        },
         "PLUGIN_SOFAMATRIX": {
           "type": "BOOL",
           "value": "ON"
@@ -220,14 +212,6 @@
           "type": "BOOL",
           "value": "ON"
         },
-        "SOFA_FETCH_CGALPLUGIN": {
-          "type": "BOOL",
-          "value": "ON"
-        },
-        "PLUGIN_CGALPLUGIN": {
-          "type": "BOOL",
-          "value": "ON"
-        },
         "SOFA_FETCH_SOFA_METIS": {
           "type": "BOOL",
           "value": "ON"

Sofa/Component/Mass/src/sofa/component/mass/DiagonalMass.h

@@ -54,7 +54,6 @@ public :
 * @class    DiagonalMass
 * @brief    This component computes the integral of this mass density over the volume of the object geometry but it supposes that the Mass matrix is diagonal.
 * @remark   Similar to MeshMatrixMass but it does not simplify the Mass Matrix as diagonal.
-* @remark   https://www.sofa-framework.org/community/doc/components/masses/diagonalmass/
 * @tparam   DataTypes type of the state associated with this mass
 * @tparam   GeometricalTypes type of the geometry, i.e type of the state associated with the topology (if the topology and the mass relates to the same state, this will be the same as DataTypes)
 */

Sofa/Component/Mass/src/sofa/component/mass/MeshMatrixMass.h

@@ -57,7 +57,6 @@ template <class DataTypes, class TMassType>
 * @class    MeshMatrixMass
 * @brief    This component computes the integral of this mass density over the volume of the object geometry.
 * @remark   Similar to DiagonalMass which simplifies the Mass Matrix as diagonal.
-* @remark   https://www.sofa-framework.org/community/doc/components/masses/meshmatrixmass/
 * @tparam   DataTypes type of the state associated to this mass
 * @tparam   GeometricalTypes type of the geometry, i.e type of the state associated with the topology (if the topology and the mass relates to the same state, this will be the same as DataTypes)
 */

Sofa/Component/SolidMechanics/FEM/Elastic/src/sofa/component/solidmechanics/fem/elastic/HexahedronFEMForceField.inl

@@ -259,28 +259,26 @@ void HexahedronFEMForceField<DataTypes>::addDForce (const core::MechanicalParams
     typename VecElement::const_iterator it;
 
     const auto* indexedElements = this->getIndexedElements();
+    const auto& elementStiffnesses = d_elementStiffnesses.getValue();
 
     for(it = indexedElements->begin() ; it != indexedElements->end() ; ++it, ++i)
     {
-        // Transformation R_0_2;
-        // R_0_2.transpose(_rotations[i]);
 
-        Displacement X;
+        Displacement X(sofa::type::NOINIT);
 
-        for(int w=0; w<8; ++w)
+        for (int w = 0; w < 8; ++w)
         {
-            Coord x_2;
-            x_2 = _rotations[i] * _dx[(*it)[w]];
+            const Coord x_2 = _rotations[i] * _dx[(*it)[w]];
 
             X[w*3] = x_2[0];
             X[w*3+1] = x_2[1];
             X[w*3+2] = x_2[2];
         }
 
-        Displacement F;
-        computeForce(F, X, d_elementStiffnesses.getValue()[i] );
+        Displacement F(sofa::type::NOINIT);
+        computeForce(F, X, elementStiffnesses[i] );
 
-        for(int w=0; w<8; ++w)
+        for (int w = 0; w < 8; ++w)
         {
             _df[(*it)[w]] -= _rotations[i].multTranspose(Deriv(F[w*3], F[w*3+1], F[w*3+2])) * kFactor;
         }

Sofa/GL/src/sofa/gl/VideoRecorderFFMPEG.cpp

@@ -87,22 +87,23 @@ bool VideoRecorderFFMPEG::init(const std::string& ffmpeg_exec_filepath, const st
     m_ffmpegBuffer = new unsigned char [m_ffmpegBufferSize];
 
     m_FrameCount = 0;
-
+    std::string extension;
+#ifdef WIN32
+    extension = ".exe";
+#endif
     m_ffmpegExecPath = ffmpeg_exec_filepath;
     if(m_ffmpegExecPath.empty())
     {
-        std::string extension;
-#ifdef WIN32
-        extension = ".exe";
-#endif
         m_ffmpegExecPath = helper::Utils::getExecutablePath() + "/ffmpeg" + extension;
-        if(!FileSystem::isFile(m_ffmpegExecPath))
-        {
-            // Fallback to a relative FFMPEG (may be in system or exposed in PATH)
-            m_ffmpegExecPath = "ffmpeg" + extension;
-        }
+    }
+    if(!FileSystem::isFile(m_ffmpegExecPath, true))
+    {
+        msg_warning("VideoRecorderFFMPEG")<< "ffmpeg hasn't been found automatically. Falling back to simply calling ffmpeg"<< extension <<" and hope that the OS finds it on its own. " ;
+        // Fallback to a relative FFMPEG (may be in system or exposed in PATH)
+        m_ffmpegExecPath = "ffmpeg" + extension;
     }
 
+
     std::stringstream ss;
     ss << m_ffmpegExecPath
        << " -r " << m_framerate
@@ -122,6 +123,7 @@ bool VideoRecorderFFMPEG::init(const std::string& ffmpeg_exec_filepath, const st
 #else
     m_ffmpeg = popen(command_line.c_str(), "w");
 #endif
+
     if (m_ffmpeg == nullptr) {
         msg_error("VideoRecorderFFMPEG") << "ffmpeg process failed to open (error " << errno << "). Command line : " << command_line;
         return false;
@@ -138,31 +140,38 @@ void VideoRecorderFFMPEG::addFrame()
 {        
     GLint viewport[4];
     glGetIntegerv(GL_VIEWPORT, viewport);
-   
+
     if ((viewport[2] != m_viewportWidth) || (viewport[3] != m_viewportHeight))
     {
         std::cout << "WARNING viewport changed during video capture from " << m_viewportWidth << "x" << m_viewportHeight << "  to  " << viewport[2] << "x" << viewport[3] << std::endl;
     }
 
+    glReadPixels(viewport[0], viewport[1], m_viewportWidth, m_viewportHeight, GL_RGBA, GL_UNSIGNED_BYTE, (void*)m_viewportBuffer);
+
+    addFrame(m_viewportBuffer, m_viewportWidth, m_viewportHeight);
+}
 
-    glReadPixels(0, 0, m_viewportWidth, m_viewportHeight, GL_RGBA, GL_UNSIGNED_BYTE, (void*)m_viewportBuffer);
 
-    // set ffmpeg buffer: initialize to 0 (black) 
+
+void VideoRecorderFFMPEG::addFrame(unsigned char* rgbData, int fbWidth, int fbHeight)
+{
+
+    // set ffmpeg buffer: initialize to 0 (black)
     memset(m_ffmpegBuffer, 0, m_ffmpegBufferSize);
 
-    if (m_viewportWidth == m_ffmpegWidth)
+    if (fbWidth == m_ffmpegWidth)
     {
-        memcpy(m_ffmpegBuffer, m_viewportBuffer, m_viewportBufferSize);
+        memcpy(m_ffmpegBuffer, rgbData, fbHeight * fbWidth * m_pixelFormatSize);
     }
     else
     {
-        const unsigned char* viewportBufferIter = m_viewportBuffer;
-        const size_t viewportRowSizeInBytes = m_pixelFormatSize * m_viewportWidth;
+        const unsigned char* viewportBufferIter = rgbData;
+        const size_t viewportRowSizeInBytes = m_pixelFormatSize * fbWidth;
 
         unsigned char* ffmpegBufferIter = m_ffmpegBuffer;
         const size_t ffmpegRowSizeInBytes = m_pixelFormatSize * m_ffmpegWidth;
 
-        int row = m_viewportHeight;
+        int row = fbHeight;
         while ( row-- > 0 )
         {
             memcpy( ffmpegBufferIter, viewportBufferIter, viewportRowSizeInBytes);
@@ -174,8 +183,6 @@ void VideoRecorderFFMPEG::addFrame()
 
 
     fwrite(m_ffmpegBuffer, m_ffmpegBufferSize, 1, m_ffmpeg);
-    
-    return;
 }
 
 void VideoRecorderFFMPEG::finishVideo()

Sofa/GL/src/sofa/gl/VideoRecorderFFMPEG.h

@@ -62,9 +62,14 @@ class SOFA_GL_API VideoRecorderFFMPEG
     bool init(const std::string& ffmpeg_exec_filepath, const std::string& filename, int width, int height, unsigned int framerate, unsigned int bitrate, const std::string& codec="");
 
     void addFrame();
+    void addFrame(unsigned char* rgbData, int fbWidth, int fbHeight);
     void saveVideo();
     void finishVideo();
 
+    int getPixelFormatSize()
+    {
+        return m_pixelFormatSize;
+    };
 
     void setPrefix(const std::string v) { m_prefix = v; }
 

Sofa/framework/Core/src/sofa/core/ObjectFactory.cpp

@@ -279,10 +279,14 @@ objectmodel::BaseObject::SPtr ObjectFactory::createObject(objectmodel::BaseConte
                     possibleNames.emplace_back(k.first);
                 }
 
-                arg->logError("But the following object(s) exist:");
-                for(auto& [name, score] : sofa::helper::getClosestMatch(classname, possibleNames, 5, 0.6))
+                const auto closestMatches = sofa::helper::getClosestMatch(classname, possibleNames, 5, 0.6);
+                if (!closestMatches.empty())
                 {
-                    arg->logError( "                      : " + name + " ("+ std::to_string((int)(100*score))+"% match)");
+                    arg->logError("But the following object(s) exist:");
+                    for(auto& [name, score] : closestMatches)
+                    {
+                        arg->logError( "                      : " + name + " ("+ std::to_string((int)(100*score))+"% match)");
+                    }
                 }
             }
         }

Sofa/framework/Core/src/sofa/core/visual/DrawMesh.h

@@ -141,6 +141,58 @@ struct BaseDrawMesh
 template<class ElementType>
 struct DrawElementMesh{};
 
+template<>
+struct SOFA_CORE_API DrawElementMesh<sofa::geometry::Edge>
+    : public BaseDrawMesh<DrawElementMesh<sofa::geometry::Edge>, 2>
+{
+    using ElementType = sofa::geometry::Edge;
+    friend BaseDrawMesh;
+    static constexpr ColorContainer defaultColors {
+        sofa::type::RGBAColor::lime(),
+        sofa::type::RGBAColor::silver()
+    };
+
+private:
+    template<class PositionContainer, class IndicesContainer>
+    void doDraw(
+        sofa::helper::visual::DrawTool* drawTool,
+        const PositionContainer& position,
+        sofa::core::topology::BaseMeshTopology* topology,
+        const IndicesContainer& elementIndices,
+        const ColorContainer& colors)
+    {
+        if (!topology)
+            return;
+
+        const auto& elements = topology->getEdges();
+
+        const auto size = elementIndices.size() * sofa::geometry::Edge::NumberOfNodes;
+        for ( auto& p : renderedPoints)
+        {
+            p.resize(size);
+        }
+
+        std::array<std::size_t, NumberColors> renderedPointId {};
+        for (auto i : elementIndices)
+        {
+            const auto& element = elements[i];
+
+            const auto center = this->elementCenter(position, element);
+
+            for (std::size_t j = 0; j < sofa::geometry::Edge::NumberOfNodes; ++j)
+            {
+                const auto p = this->applyElementSpace(position[element[j]], center);
+                renderedPoints[i % NumberColors][renderedPointId[i%NumberColors]++] = sofa::type::toVec3(p);
+            }
+        }
+
+        for (std::size_t j = 0; j < NumberColors; ++j)
+        {
+            drawTool->drawLines(renderedPoints[j], 2.f, colors[j]);
+        }
+    }
+};
+
 template<>
 struct SOFA_CORE_API DrawElementMesh<sofa::geometry::Triangle>
     : public BaseDrawMesh<DrawElementMesh<sofa::geometry::Triangle>, 3>
@@ -194,6 +246,59 @@ struct SOFA_CORE_API DrawElementMesh<sofa::geometry::Triangle>
     }
 };
 
+
+template<>
+struct SOFA_CORE_API DrawElementMesh<sofa::geometry::Quad>
+    : public BaseDrawMesh<DrawElementMesh<sofa::geometry::Quad>, 2>
+{
+    using ElementType = sofa::geometry::Quad;
+    friend BaseDrawMesh;
+    static constexpr ColorContainer defaultColors {
+        sofa::type::RGBAColor::green(),
+        sofa::type::RGBAColor::orange()
+    };
+
+private:
+    template<class PositionContainer, class IndicesContainer>
+    void doDraw(
+        sofa::helper::visual::DrawTool* drawTool,
+        const PositionContainer& position,
+        sofa::core::topology::BaseMeshTopology* topology,
+        const IndicesContainer& elementIndices,
+        const ColorContainer& colors)
+    {
+        if (!topology)
+            return;
+
+        const auto& elements = topology->getQuads();
+
+        const auto size = elementIndices.size() * sofa::geometry::Quad::NumberOfNodes;
+        for ( auto& p : renderedPoints)
+        {
+            p.resize(size);
+        }
+
+        std::array<std::size_t, NumberColors> renderedPointId {};
+        for (auto i : elementIndices)
+        {
+            const auto& element = elements[i];
+
+            const auto center = this->elementCenter(position, element);
+
+            for (std::size_t j = 0; j < sofa::geometry::Quad::NumberOfNodes; ++j)
+            {
+                const auto p = this->applyElementSpace(position[element[j]], center);
+                renderedPoints[i % NumberColors][renderedPointId[i%NumberColors]++] = sofa::type::toVec3(p);
+            }
+        }
+
+        for (std::size_t j = 0; j < NumberColors; ++j)
+        {
+            drawTool->drawQuads(renderedPoints[j], colors[j]);
+        }
+    }
+};
+
 template<>
 struct SOFA_CORE_API DrawElementMesh<sofa::geometry::Tetrahedron>
     : public BaseDrawMesh<DrawElementMesh<sofa::geometry::Tetrahedron>, 4>
@@ -338,10 +443,17 @@ class SOFA_CORE_API DrawMesh
 
     void setElementSpace(SReal elementSpace);
 
+    template<class PositionContainer>
+    void drawLine(sofa::helper::visual::DrawTool* drawTool, const PositionContainer& position, sofa::core::topology::BaseMeshTopology* topology)
+    {
+        drawElements<sofa::geometry::Edge>(drawTool, position, topology);
+    }
+
     template<class PositionContainer>
     void drawSurface(sofa::helper::visual::DrawTool* drawTool, const PositionContainer& position, sofa::core::topology::BaseMeshTopology* topology)
     {
         drawElements<sofa::geometry::Triangle>(drawTool, position, topology);
+        drawElements<sofa::geometry::Quad>(drawTool, position, topology);
     }
 
     template<class PositionContainer>
@@ -359,19 +471,38 @@ class SOFA_CORE_API DrawMesh
             return;
         }
 
-        const auto hasTetra = topology && !topology->getTetrahedra().empty();
-        const auto hasHexa = topology && !topology->getHexahedra().empty();
+        const auto hasTriangles = !topology->getTriangles().empty();
+        const auto hasQuads = !topology->getQuads().empty();
+
+        const auto hasSurfaceElements = hasTriangles || hasQuads;
+
+        const auto hasTetra = !topology->getTetrahedra().empty();
+        const auto hasHexa = !topology->getHexahedra().empty();
+
+        const bool hasVolumeElements = hasTetra || hasHexa;
 
-        if (!hasTetra && !hasHexa)
+        if (!hasSurfaceElements && !hasVolumeElements)
         {
-            drawSurface(drawTool, position, topology);
+            drawLine(drawTool, position, topology);
+        }
+        else
+        {
+            if (!hasVolumeElements)
+            {
+                drawSurface(drawTool, position, topology);
+            }
+            else
+            {
+                drawVolume(drawTool, position, topology);
+            }
         }
-        drawVolume(drawTool, position, topology);
     }
 
 private:
     std::tuple<
+        DrawElementMesh<sofa::geometry::Edge>,
         DrawElementMesh<sofa::geometry::Triangle>,
+        DrawElementMesh<sofa::geometry::Quad>,
         DrawElementMesh<sofa::geometry::Tetrahedron>,
         DrawElementMesh<sofa::geometry::Hexahedron>
     > m_meshes;