Simplify unbend( and bend() usage

Author: VEZY

Diff for: NAMESPACE

@@ -9,6 +9,7 @@ export(Rota_Inverse_YZ)
 export(Rota_YZ)
 export(XYZ_Vers_Agl)
 export(bend)
+export(distance_weight_sine)
 export(plot_bending)
 export(plot_bending_3d)
 export(read_mat)

Diff for: R/XYZ_Vers_Agl.R

@@ -13,8 +13,7 @@
 #'
 #' @examples
 #' filepath = system.file("extdata/6_EW01.22_17_kanan.txt", package = "biomech")
-#' df = read_mat(filepath)
-#' df = unbend(2000,400,df)
+#' df = unbend(read_mat(filepath))
 #' XYZ_Vers_Agl(df$x,df$y,df$z)
 #'
 XYZ_Vers_Agl = function(vecX, vecY, vecZ){

Diff for: R/application_distance.R

@@ -0,0 +1,17 @@
+#' Weight distance of application
+#'
+#' Computes the distance of application of the right/left weights using a sine
+#' evolution along the beam.
+#'
+#' @param x  X position of the segments
+#' @param dF Amplitude (m)
+#'
+#' @return The distance at which the left/right weights are applied from the beam axis. Both
+#'  sides are considered equal.
+#' @export
+#'
+#' @examples
+#' distance_weight_sine(c(1,2,3))
+distance_weight_sine = function(x,dF = 0.1){
+  sin(x / x[length(x)] * pi) * dF
+}

Diff for: R/bend.R

@@ -3,26 +3,26 @@
 #' Compute the deformation by applying both bending and torsion
 #'
 #' @param data Point data.frame (see details).
+#' @param elastic_modulus Elasticity modulus (bending, MPa)
+#' @param shear_modulus shear modulus (torsion, MPa)
 #' @param step Length of the segments that discretize the object (m).
 #' @param points Number of points used in the grid discretizing the section.
 #' @param iterations Number of iterations to compute the torsion and bending
 #' @param verbose Boolean. Return information during procress?
 #'
 #' @details The data argument is a [data.frame()] with each row being a point and each column being:
-#' - x: x coordinate
-#' - y: y coordinate
-#' - z: z coordinate
-#' - type: section type. 1: triangle (bottom-oriented); 2 : rectangle; 3 : triangle (top-oriented);
+#' - x: x coordinate of the segment
+#' - y: y coordinate of the segment
+#' - z: z coordinate of the segment
+#' - type: section type of the segment. 1: triangle (bottom-oriented); 2 : rectangle; 3 : triangle (top-oriented);
 #' 4 : ellipsis; 5 : circle.
-#' - width (m): section width
-#' - height (m): section height
-#' - mass (kg): mass of the section at the point
-#' - mass_right (kg): mass carried by the object, on the right side
-#' - mass_left (kg): mass carried by the object, on the left side
-#' - elastic_modulus (MPa): elasticity modulus (bending)
-#' - shear_modulus (MPa): shear modulus (torsion)
-#' - inclination (degree): insertion angle of the first section (only first value is used)
-#' - distance_application (m): application distances for the left and right weights
+#' - width (m): segment section width
+#' - height (m): segment section height
+#' - mass (kg): mass of the segment
+#' - mass_right (kg): mass carried by the segment, on the right side
+#' - mass_left (kg): mass carried by the segment, on the left side
+#' - torsion (degree): initial torsion angle of the segment
+#' - distance_application (m): application distances for the left and right weights (see e.g. [distance_weight_sine()])
 #'
 #' @return A [data.frame()]:
 #' - x (m): X coordinate
@@ -37,12 +37,17 @@
 #'
 #' @examples
 #' filepath = system.file("extdata/6_EW01.22_17_kanan.txt", package = "biomech")
+#' df = read_mat(filepath)
 #' # Un-bending the field measurements:
-#' df = unbend(2000,400, read_mat(filepath))
+#' df = unbend(df)
+#'
+#' # Adding the distance of application of the left and right weight:
+#' df$distance_application = distance_weight_sine(df$x)
 #'
 #' # (Re-)computing the deformation:
-#' df_bend = bend(df, step = 0.02, points = 100, iterations = 15, verbose = TRUE)
-bend = function(data, step = 0.02, points = 100,
+#' df_bend = bend(df, elastic_modulus = 2000, shear_modulus = 400, step = 0.02, points = 100,
+#'                iterations = 15, verbose = TRUE)
+bend = function(data,elastic_modulus,shear_modulus, step = 0.02, points = 100,
                 iterations = 15, verbose = TRUE){
 
   vecRotFlex = matrix(0, ncol = 1, nrow = 3)
@@ -91,10 +96,26 @@ bend = function(data, step = 0.02, points = 100,
   step = distTotale / (Nlin - 1)
   vecDist = (0 : (Nlin - 1)) * step
 
-  vMOE = data$elastic_modulus
+  if(length(elastic_modulus) != nrow(data)){
+    if(length(elastic_modulus) == 1){
+      elastic_modulus = rep(elastic_modulus, nrow(data))
+    }else{
+      stop("elastic_modulus argument should be of length 1 or equal to `nrow(data)`")
+    }
+  }
+
+  if(length(shear_modulus) != nrow(data)){
+    if(length(shear_modulus) == 1){
+      shear_modulus = rep(shear_modulus, nrow(data))
+    }else{
+      stop("shear_modulus argument should be of length 1 or equal to `nrow(data)`")
+    }
+  }
+
+  vMOE = elastic_modulus
   vecMOE = stats::approx(c(0,distLineique), c(vMOE[1], vMOE), vecDist, method = 'linear')$y
 
-  vG = data$shear_modulus
+  vG = shear_modulus
   vecG = stats::approx(c(0,distLineique), c(vG[1], vG), vecDist, method = 'linear')$y
 
   vAngle_Tor = data$torsion * pi / 180 # (radian)

Diff for: R/plot_bent.R

@@ -10,11 +10,20 @@
 #' @importFrom rlang .data
 #'
 #' @examples
-#' filepath = system.file("extdata/6_EW01.22_17_kanan.txt", package = "biomech")
+#' file_path = system.file("extdata/6_EW01.22_17_kanan.txt", package = "biomech")
+#' field_data = read_mat(file_path)
 #' # Un-bending the field measurements:
-#' df = unbend(2000,400, read_mat(filepath))
-#' df_bend = bend(df, step = 0.02, points = 100, iterations = 15, verbose = TRUE)
-#' plot_bending(df_bend,df)
+#' df_unbent = unbend(field_data)
+#'
+#' # Adding the distance of application of the left and right weight:
+#' df_unbent$distance_application = distance_weight_sine(df_unbent$x)
+#'
+#' # (Re-)computing the deformation:
+#' df_bent = bend(df_unbent, elastic_modulus = 2000, shear_modulus = 400, step = 0.02,
+#'                points = 100, iterations = 15, verbose = TRUE)
+#'
+#' # And finally, plotting:
+#' plot_bending(df_bent,df_unbent)
 plot_bending = function(bent, unbent = NULL, ...){
   plot_range = range(bent$x,bent$y,bent$z,unbent$x,unbent$y,unbent$z)
   plot_range_max = max(plot_range)
@@ -55,7 +64,7 @@ plot_bending_3d = function(bent, unbent = NULL, ...){
     {
       if(!is.null(unbent)){
         plotly::add_trace(p = ., data = unbent, x = ~x, y = ~y, z = ~z,
-                          name = "Initial state")
+                          name = "Un-bent")
       }else{
         .
       }

Diff for: R/unbend.R

@@ -1,124 +1,60 @@
 #' Unbend
 #'
-#' Takes measurements from field that are already bent (torsion + bending) and transform them
-#' to a straight line (un-bending).
-#' Mainly used to compute the matrix for input to [bend()] from experimental points.
+#' Remove torsion and bending of a bent beam, i.e. transform it
+#' into a straight line, while keeping its insertion angle (inclination angle of the first segment).
+#'
+#' @note Mainly used to compute the matrix for input to [bend()] from experimental points.
 #'
-#' @param MOE Elastic modulus
-#' @param CIS Shear modulus
 #' @param df Experimental data (usually read using [read_mat()], see details)
 #'
 #' @details df should be a formatted [data.frame()], with each row being a point and each columns being:
 #' - distance (m): distance between the previous point and this point (first value should be positive)
-#' - type: section type. 1: triangle (bottom-oriented); 2 : rectangle; 3 : triangle (top-oriented);
-#' 4 : ellipsis; 5 : circle.
-#' - width (m): section width
-#' - height (m): section height
 #' - inclination (degree): insertion angle of the first point (only first value is used)
-#' - torsion (degree): torsion angle
-#' - x: x coordinate (optional, only for plotting)
-#' - y: y coordinate (optional, only for plotting)
-#' - z: z coordinate (optional, only for plotting)
-#' - mass (kg): mass of the section at the point
-#' - mass_right (kg): mass carried by the object, on the right side
-#' - mass_left (kg): mass carried by the object, on the left side
 #'
-#' @return A [data.frame()]:
+#' @return The input [data.frame()] with modified (or enriched with):
 #' - x: x coordinate
 #' - y: y coordinate
 #' - z: z coordinate
-#' - type: section type. 1: triangle (bottom-oriented); 2 : rectangle; 3 : triangle (top-oriented);
-#' 4 : ellipsis; 5 : circle.
-#' - width (m): section width
-#' - height (m): section height
-#' - mass (kg): mass of the section at the point
-#' - mass_right (kg): mass carried by the object, on the right side
-#' - mass_left (kg): mass carried by the object, on the left side
-#' - elastic_modulus (MPa): elasticity modulus (bending)
-#' - shear_modulus (MPa): shear modulus (torsion)
-#' - inclination (degree): insertion angle of the first section (only first value is used)
-#' - distance_application (m): application distances for the left and right weights
 #'
 #' @export
 #'
 #' @examples
 #' \dontrun{
 #' filepath = system.file("extdata/6_EW01.22_17_kanan.txt", package = "biomech")
 #' df = read_mat(filepath)
-#' unbend(MOE = 2000, CIS = 400, df = df)
+#' unbend(df = df)
 #' }
-unbend = function(MOE, CIS, df){
+unbend = function(df){
 
-  # La distance entre les points ne peut pas etre nulle
+  # The distance between points can't be 0
   iD0 = which(df$distance == 0)
   if(length(iD0)>0){
     df$distance[iD0] = 1e-3 # (m)
   }
-  # Coordonnees des points (etat non deforme)
+
   Distance = df$distance
+
+  # cumulated distance of each segment:
   XDistance = cumsum(unlist(Distance))
 
+  # keeping the inclination of the first segment (i.e. insertion angle):
   Agl_Y = df$inclination[1] * pi / 180
   Agl_Z = 0
 
-  NpointsExp = length(Distance)
+  # Initializing in case they are missing:
+  df$x = df$y = df$z = 0
 
-  X = Y = Z = rep(0, NpointsExp)
-
-  # Segment de droite oriente dans un espace 3D
-  for(iter in 1 : NpointsExp){
+  # Coordinates of the points (un-bent state):
+  for(iter in 1 : nrow(df)){
     OP = c(XDistance[[iter]], 0, 0)
     vecRot = Rota_YZ(OP, Agl_Y, Agl_Z)
 
-    X[iter] = vecRot[1]
-    Y[iter] = vecRot[2]
-    Z[iter] = vecRot[3]
+    df$x[iter] = vecRot[1]
+    df$y[iter] = vecRot[2]
+    df$z[iter] = vecRot[3]
   }
 
-  # Affichage graphique
-  # if (gph == 1)
-  #   figure, hold on
-  # plot3(df(iX,:), df(iY,:), df(iZ,:), 'bo--')
-  # plot3(X, Y, Z, 'ko--')
-  # xlabel('X (m)'), ylabel('Y (m)'), zlabel('Z (m)')
-  # title('Etat deforme (mesures experimentales) et non deforme')
-  # axis('equal'), grid on, view(45, 25)
-  # end
-
-  # Section
-  TypeSection = df$type
-  Base = df$width
-  Hauteur = df$height
-
-  # Poids
-  PoidsTige = df$mass
-  PoidsFeuillesDroite = df$mass_right
-  PoidsFeuillesGauche = df$mass_left
-
-  # Elasticite
-  # Valeur constante
-  ModuleElasticite = rep(MOE, NpointsExp)
-  ModuleCisaillement = rep(CIS, NpointsExp)
-
-  # Orientations initales des sections
-  AngleSection = df$torsion
-
-  # Distance d'application du poids des feuilles
-  # Evolution sinus, valeur arbitraire de dF
-  # Le ratio dF/CIS est optimise
-  dF = 0.1
-  DAppliPoidsFeuil = sin(XDistance / utils::tail(XDistance,1) * pi) * dF
-
-  #===============================================================================
-  # Resultats
-  df = data.frame(x= X, y = Y, z = Z, type = TypeSection, width = Base,
-                  height = Hauteur, mass = PoidsTige, mass_right = PoidsFeuillesDroite,
-                  mass_left = PoidsFeuillesGauche,
-                  elastic_modulus = ModuleElasticite,
-                  shear_modulus = ModuleCisaillement,
-                  torsion = AngleSection,
-                  distance_application = DAppliPoidsFeuil)
-  class(df) = append("unbent",class(df))
   df
 }
 
+

Diff for: README.Rmd

@@ -37,27 +37,32 @@ Here is an example usage:
 
 ```{r example}
 library(biomech)
-filepath = system.file("extdata/6_EW01.22_17_kanan.txt", package = "biomech")
+file_path = system.file("extdata/6_EW01.22_17_kanan.txt", package = "biomech")
+field_data = read_mat(file_path)
 # Un-bending the field measurements:
-df = unbend(2000,400, read_mat(filepath))
+df_unbent = unbend(field_data)
+
+# Adding the distance of application of the left and right weight:
+df_unbent$distance_application = distance_weight_sine(df_unbent$x)
+
 # (Re-)computing the deformation:
-df_bend = bend(df, step = 0.02, points = 100, iterations = 15, verbose = TRUE)
+df_bent = bend(df_unbent, elastic_modulus = 2000, shear_modulus = 400, step = 0.02, points = 100, iterations = 15, verbose = TRUE)
 
-df_bend
+df_bent
 ```
 
 You can plot the results using:
 
 ```{r}
-plot_bending(bent = df_bend, unbent = df)
+plot_bending(bent = df_bent, unbent = df_unbent)
 ```
 
 Note that the `unbent` argument is optional but can be very usefull to compare with the initial conditions.
 
 You can even make 3d plots using `plot_bent_3d()`:
 
 ```{r eval=FALSE}
-plot_bending_3d(df_bend,df)
+plot_bending_3d(df_bent,df_unbent)
 ```
 
 ```{r echo=FALSE}