Methods

{
  "name": "VisualState",
  "namespace": "sofa::core::visual",
  "module": "Sofa.framework.Core",
  "include": "sofa/core/visual/VisualState.h",
  "doc": "",
  "inherits": [
    "State"
  ],
  "templates": [
    "sofa::defaulttype::Vec3Types"
  ],
  "data_fields": [],
  "links": [],
  "methods": [
    {
      "name": "resize",
      "return_type": "void",
      "params": [
        {
          "name": "vsize",
          "type": "int"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "getSize",
      "return_type": "int",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "write",
      "return_type": "Data<VecCoord> *",
      "params": [
        {
          "name": "v",
          "type": "core::VecCoordId"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "read",
      "return_type": "const Data<VecCoord> *",
      "params": [
        {
          "name": "v",
          "type": "core::ConstVecCoordId"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "write",
      "return_type": "Data<VecDeriv> *",
      "params": [
        {
          "name": "v",
          "type": "core::VecDerivId"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "read",
      "return_type": "const Data<VecDeriv> *",
      "params": [
        {
          "name": "v",
          "type": "core::ConstVecDerivId"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "write",
      "return_type": "Data<MatrixDeriv> *",
      "params": [
        {
          "name": "",
          "type": "core::MatrixDerivId"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "read",
      "return_type": "const Data<MatrixDeriv> *",
      "params": [
        {
          "name": "",
          "type": "core::ConstMatrixDerivId"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    }
  ],
  "description": "The `VisualState` component in the SOFA framework is designed to manage visual representations and state data for graphical rendering, primarily handling vertex coordinates, rest positions, and normals. It inherits from `State`, allowing it to integrate seamlessly into the scene graph architecture. The component supports resizing of its internal data structures (`positions`, `restPositions`, `normals`) using the `resize` method, which adjusts the size according to the input parameter `vsize`. Methods like `getSize` provide information on the current number of elements managed by the state.\n\nInteractions with other components are facilitated through methods such as `write` and `read`, which allow access to vertex coordinates (`VecCoord`) and normals (`VecDeriv`). These methods support both write and read operations, ensuring that data can be updated or queried as needed. The component also handles modifications by setting a boolean flag indicating whether the input vertices have been modified since the last rendering.\n\nPractical usage involves initializing `VisualState` with appropriate vertex and normal data structures, resizing them when necessary, and accessing these data through the provided methods for rendering purposes.",
  "maths": "The `VisualState` component in the SOFA framework is primarily concerned with managing visual representations and state data for graphical rendering. It does not directly implement or contribute to any governing equations, constitutive laws, or kinematic relations typical of a finite element method (FEM) simulation pipeline. Instead, it focuses on handling vertex coordinates, rest positions, and normals which are essential for visualization purposes but do not involve the mathematical machinery associated with physical simulations.\n\n### Role in Global FEM Pipeline:\n- **Assembly**: The `VisualState` component does not directly participate in the assembly of global matrices or vectors such as the mass matrix (\\(M\")), internal force vector (\\(f_{int}\")), residual vector (\\(R\")), etc. It is a passive container for state data.\n\n- **Time Integration**: This component plays no role in time integration schemes, which involve solving equations like the implicit Euler or Newmark methods to advance the simulation in time.\n\n- **Nonlinear Solve / Linear Solve**: The `VisualState` does not contribute to nonlinear solve steps (e.g., Newton-Raphson iterations) or linear solves (e.g., using iterative solvers).\n\n### Numerical Methods and Discretization Choices:\n- While the component is designed to store and manage vertex coordinates and normals, it does not implement any specific discretization schemes for the physical simulation. It merely provides a structured storage and access mechanism for these graphical elements.\n\n### Integration into Variational / Lagrangian Mechanics Framework:\n- The `VisualState` component does not integrate directly with variational or Lagrangian mechanics principles, as it is focused on visualization rather than physical modeling.\n\n### Summary of Mathematical Content:\n- **Vertex Coordinates**: Stored in the member variable `m_positions`. Represents the current positions of vertices for rendering purposes.\n  \n    \\[ X_i = m_{\text{positions}}[i] \\]\n\n- **Rest Positions**: The rest positions are stored in `m_restPositions`, representing the undeformed configuration of the vertices. These can be useful for visualizing deformations, but they do not directly participate in any FEM simulation.\n  \n    \\[ X_i^{\text{rest}} = m_{\text{restPositions}}[i] \\]\n\n- **Normals**: The normals are stored in `m_vnormals`, which can be used for shading and other graphical effects. These do not participate in any physical simulation but are crucial for visual realism.\n  \n    \\[ N_i = m_{\text{vnormals}}[i] \\]\n\n- **Size Management**: The `resize` method allows the component to adjust its internal data structures according to the input parameter `vsize`, ensuring that the number of vertices and normals match the requirements.\n  \n    \\[ \text{resize}(vsize) : |\text{m_positions}| = vsize \\]\n\n- **Read/Write Methods**: The methods `write` and `read` provide access to these data structures, allowing for updating or querying vertex coordinates and normals as needed during the simulation loop.\n  \n    \\[ m_{\text{positions}}.resize(vsize) \\] and similarly for `m_restPositions`, `m_vnormals`\n\n### Conclusion:\n- The `VisualState` component is designed to handle graphical data necessary for rendering, such as vertex positions, rest positions, and normals. It does not contribute any physical simulation content or mathematical operators that are typical of an FEM pipeline.",
  "abstract": "Manages visual state data including vertex coordinates, rest positions, and normals for graphical rendering in SOFA simulations.",
  "sheet": "# VisualState\n\n## Overview\nThe `VisualState` component manages the visual representation of objects by handling vertex coordinates (`m_positions`), rest positions (`m_restPositions`), and normals (`m_vnormals`). It inherits from `State`, allowing it to integrate into the SOFA scene graph architecture. The component provides methods for resizing its internal data structures, reading, and writing state data.\n\n## Parameters and Data\nThe `VisualState` component does not expose any significant Data fields directly; instead, it manages internal data structures through methods such as `resize`, `write`, and `read`. These methods allow the manipulation of vertex coordinates (`VecCoord`), rest positions (`VecDeriv`), and normals (`MatrixDeriv`).\n\n- **Vertex Coordinates**: Stored in `m_positions`\n    \n    \\[ X_i = m_{\\text{positions}}[i] \\]\n\n- **Rest Positions**: Stored in `m_restPositions`\n    \n    \\[ X_i^{\\text{rest}} = m_{\\text{restPositions}}[i] \\]\n\n- **Normals**: Stored in `m_vnormals`\n    \n    \\[ N_i = m_{\\text{vnormals}}[i] \\]"
}