Auto-merge from CI

Author: madhephaestus

docs/Bowler-Kinematics/Advanced_Kinematics/index.html

@@ -131,30 +131,24 @@
         <div class="col-sm-9" role="main">
             <div class="bs-docs-section">
 
+<h2 id="jacobian">Jacobian</h2>
 
-##Jacobian
+<p>For Kinematic systems, the Task Space is used to describe the global coordinates, where the task is being performed.  Forward Kinematics solves for the Task Space based on the robot properties.  The Joint Space is the internal robot reference system, which typically includes the joint angles, lengths and offsets.  Inverse Kinematics solves for the Joint Space from the Task Space.  Both are important ways of modeling jobs and systems, and being able to convert between them are absolutely critical in modeling and job functionality.</p>
 
-For Kinematic systems, the Task Space is used to describe the global coordinates, where the task is being performed.  Forward Kinematics solves for the Task Space based on the robot properties.  The Joint Space is the internal robot reference system, which typically includes the joint angles, lengths and offsets.  Inverse Kinematics solves for the Joint Space from the Task Space.  Both are important ways of modeling jobs and systems, and being able to convert between them are absolutely critical in modeling and job functionality.
+<p>A Jacobian Matrix defines the physical properties and is used in both Forward and Inverse Kinematics models to translate between the Task and Joint spaces.  The Jacobian matrix, which is calculated from the DH parameters and current pose of the system, multiplied by the Joint Space Velocity matrix gives the Task Space Velocity.  The Inverse Kinematics side can get much more complicated as adjusting this equation to solve for the Joint space means taking the inverse of the Jacobian matrix.</p>
 
-A Jacobian Matrix defines the physical properties and is used in both Forward and Inverse Kinematics models to translate between the Task and Joint spaces.  The Jacobian matrix, which is calculated from the DH parameters and current pose of the system, multiplied by the Joint Space Velocity matrix gives the Task Space Velocity.  The Inverse Kinematics side can get much more complicated as adjusting this equation to solve for the Joint space means taking the inverse of the Jacobian matrix.
+<h2 id="inverse-jacobian">Inverse Jacobian</h2>
 
-##Inverse Jacobian
-
-By definition, the inverse of a matrix is what needs to be multiplied by a matrix to result in the identity matrix.  Only square matrices can have inverses, and not all square matrices can be inverted (and are called noninvertible or singular).  In kinematics, the Jacobian matrix size is based on both the number of links and degrees of freedom.  The three possible conditions are where the system DOF and the number of links are: equal, greater than or less than.  There will only be a square Jacobian when the system DOF and number of links are equal.  When the system DOF is greater than the number of links, it is very possible that not all desired states are achievable.  When the number of links is greater than the system DOF, over-articulation is possible.  This means that there may be multiple poses that give a solution to one particular task space.  A 6 link system in a 3 DOF space (x,y,z coordinates) will result in a Jacobian with 3 rows and 6 columns.
+<p>By definition, the inverse of a matrix is what needs to be multiplied by a matrix to result in the identity matrix.  Only square matrices can have inverses, and not all square matrices can be inverted (and are called noninvertible or singular).  In kinematics, the Jacobian matrix size is based on both the number of links and degrees of freedom.  The three possible conditions are where the system DOF and the number of links are: equal, greater than or less than.  There will only be a square Jacobian when the system DOF and number of links are equal.  When the system DOF is greater than the number of links, it is very possible that not all desired states are achievable.  When the number of links is greater than the system DOF, over-articulation is possible.  This means that there may be multiple poses that give a solution to one particular task space.  A 6 link system in a 3 DOF space (x,y,z coordinates) will result in a Jacobian with 3 rows and 6 columns.</p>
 
 <script src="https://gist.github.com/mdiblasi/9925fd3572b30419c425.js"></script>
 
-##Pseudo Jacobian
+<h2 id="pseudo-jacobian">Pseudo Jacobian</h2>
 
-Generating the Inverse Jacobian for solving the Inverse Kinematics (assuming achievable poses), isn't possible for non-square Jacobians.  In these cases, which are typically iterative rather than analytic, an approximation is appropriate, which is achieved with the Pseudo Jacobian.  The Pseudo Jacobian is calculated by manipulating the Jacobian, which has the extra benefit of avoiding a case where two sequential limbs are locked straight out, also known as a singularity condition.
+<p>Generating the Inverse Jacobian for solving the Inverse Kinematics (assuming achievable poses), isn’t possible for non-square Jacobians.  In these cases, which are typically iterative rather than analytic, an approximation is appropriate, which is achieved with the Pseudo Jacobian.  The Pseudo Jacobian is calculated by manipulating the Jacobian, which has the extra benefit of avoiding a case where two sequential limbs are locked straight out, also known as a singularity condition.</p>
 
 <script src="https://gist.github.com/mdiblasi/38c718158daeb0dda564.js"></script>
 
-
-
-
-
-
 
             </div>
         </div>

docs/Bowler-Kinematics/Analytic_Solver/index.html

@@ -131,13 +131,14 @@
         <div class="col-sm-9" role="main">
             <div class="bs-docs-section">
 
-##Analytic Solver Overview
+<h2 id="analytic-solver-overview">Analytic Solver Overview</h2>
 
-Simple robot systems can be analytically solved when constraints and degrees of freedom align.  Delta robots and 2 link revolute (rotational joint) arms are two examples of such robots that can be analytically analyzed.  A delta robot is a system with 3 identical towers or points of rotation, all connecting to one tool tip.  Depending on the configuration, it can pivot around a point or traverse the space, mirrored in 120 degree segments around the work space.  This is also a great example of Parallel links, whereas a Series system, (like the 2 link revolute arm) is a series of sequential links connected one by one.  There is one pose per achievable position since they aren't over-constrained.  It may not be possible to fully orient in every position, but mapping forward and inverse kinematics is a direct affair.
+<p>Simple robot systems can be analytically solved when constraints and degrees of freedom align.  Delta robots and 2 link revolute (rotational joint) arms are two examples of such robots that can be analytically analyzed.  A delta robot is a system with 3 identical towers or points of rotation, all connecting to one tool tip.  Depending on the configuration, it can pivot around a point or traverse the space, mirrored in 120 degree segments around the work space.  This is also a great example of Parallel links, whereas a Series system, (like the 2 link revolute arm) is a series of sequential links connected one by one.  There is one pose per achievable position since they aren’t over-constrained.  It may not be possible to fully orient in every position, but mapping forward and inverse kinematics is a direct affair.</p>
 
-##Analytic Solver Techniques
+<h2 id="analytic-solver-techniques">Analytic Solver Techniques</h2>
 
-Direct systems can be analyzed as a series of linear equations or simplified to laws of triangles.  A 2 link planar arm reaching for a point in 2D space has a limited number of ways to solve the end point.  The base position and end point are known, so the end position of link 1 is the unknown.  Drawing out the system to find that link position and with that the associated angles means equations of motion can be determined with a few simple lines of code or lower level math.  There is no standard algorithm for finding the ideal pose, and it does not need to be recursively run for optimization purposes. 
+<p>Direct systems can be analyzed as a series of linear equations or simplified to laws of triangles.  A 2 link planar arm reaching for a point in 2D space has a limited number of ways to solve the end point.  The base position and end point are known, so the end position of link 1 is the unknown.  Drawing out the system to find that link position and with that the associated angles means equations of motion can be determined with a few simple lines of code or lower level math.  There is no standard algorithm for finding the ideal pose, and it does not need to be recursively run for optimization purposes.</p>
+ 
             </div>
         </div>
     </div> <!-- row -->

docs/Bowler-Kinematics/CAD_Scripts/index.html

@@ -131,11 +131,12 @@
         <div class="col-sm-9" role="main">
             <div class="bs-docs-section">
 
-##CAD Scripts
+<h2 id="cad-scripts">CAD Scripts</h2>
 
-Simulating is great for prototyping, finding issues and tweaking the design before much time or materials are invested.  The next logical step is hardware, which is accomplished in Bowler Studio through the use of CAD Scripts.  Once the design and function are sufficient, exporting to CAD for 3D printing, machining or other rapid prototyping methods is a simple button press away.  Installing standard servos and connections couldn't be simpler, allowing for robots to go through the entire design process up to initial build quicker than ever before!
+<p>Simulating is great for prototyping, finding issues and tweaking the design before much time or materials are invested.  The next logical step is hardware, which is accomplished in Bowler Studio through the use of CAD Scripts.  Once the design and function are sufficient, exporting to CAD for 3D printing, machining or other rapid prototyping methods is a simple button press away.  Installing standard servos and connections couldn’t be simpler, allowing for robots to go through the entire design process up to initial build quicker than ever before!</p>
 
-Allowing a designer to concentrate fully on function rather than form or compatibility allows for a richer design experience, as well as lowered development time.  Robot arms, walkers or mobile robot platforms can be great productivity (or educational) tools and with the capability to have the non-function design work automated more advanced systems are possible faster than one can be ordered.  Full system approaches like Bowler Studio lower the bar for manufacturing and learning yet raise the standard on robot design. 
+<p>Allowing a designer to concentrate fully on function rather than form or compatibility allows for a richer design experience, as well as lowered development time.  Robot arms, walkers or mobile robot platforms can be great productivity (or educational) tools and with the capability to have the non-function design work automated more advanced systems are possible faster than one can be ordered.  Full system approaches like Bowler Studio lower the bar for manufacturing and learning yet raise the standard on robot design.</p>
+ 
             </div>
         </div>
     </div> <!-- row -->

docs/Bowler-Kinematics/CustomKinematics/index.html

@@ -131,9 +131,11 @@
         <div class="col-sm-9" role="main">
             <div class="bs-docs-section">
 
-Users can customize the kinematics engine with user defined D-H chains as well as custom Inverse Kinematics solvers. This lets the user define every part of the kinematic chain and control law. 
+<p>Users can customize the kinematics engine with user defined D-H chains as well as custom Inverse Kinematics solvers. This lets the user define every part of the kinematic chain and control law. </p>
 
-<script src="https://gist.github.com/madhephaestus/0e6454891a3b3f7c8f28.js"></script> 
+<script src="https://gist.github.com/madhephaestus/0e6454891a3b3f7c8f28.js"></script>
+
+ 
             </div>
         </div>
     </div> <!-- row -->

docs/Bowler-Kinematics/Iterative_Solver/index.html

@@ -131,19 +131,20 @@
         <div class="col-sm-9" role="main">
             <div class="bs-docs-section">
 
-##Iterative Solver Overview
+<h2 id="iterative-solver-overview">Iterative Solver Overview</h2>
 
-Complex robot systems may not have a 'one-size fits all' solution to kinematics, and require some sort of decision or criteria matrix to specify and choose tool paths.  Robots that have many limbs may have a large array of possible solution poses, so building a robust system to prioritize hypothetical energy efficiency, torque curves or minimize link motion can take a control system to the next level.  With more conditionals, optimizations and search criteria, the control algorithm greatly expands in complexity and computational requirements.
+<p>Complex robot systems may not have a ‘one-size fits all’ solution to kinematics, and require some sort of decision or criteria matrix to specify and choose tool paths.  Robots that have many limbs may have a large array of possible solution poses, so building a robust system to prioritize hypothetical energy efficiency, torque curves or minimize link motion can take a control system to the next level.  With more conditionals, optimizations and search criteria, the control algorithm greatly expands in complexity and computational requirements.</p>
 
-##Iterative Solver Techniques
+<h2 id="iterative-solver-techniques">Iterative Solver Techniques</h2>
 
-Standard binary search tree methods work by looking at branches to see which option is better.  By traversing the tree it's possible to directly compare each branch path and find the optimal path through the system, and by iteratively repeating the search, the ideal matches can be found.  
+<p>Standard binary search tree methods work by looking at branches to see which option is better.  By traversing the tree it’s possible to directly compare each branch path and find the optimal path through the system, and by iteratively repeating the search, the ideal matches can be found.  </p>
 
-The kinematic equivalent of this function is to have a starting pose, and 'build the tree' towards the desired end conditions.  Starting from a base position, shift the first link one step in either direction (clockwise and counterclockwise, forward and back, etc) and determine which one is closer to the end state, and saving that state.  Next, go to the next link and do the same thing, finding which direction a single step would provide a larger step towards the end goals.  When each link is tested this way, the whole operation is started again from the top, repeated until the end conditions are met or a timeout is reached.
+<p>The kinematic equivalent of this function is to have a starting pose, and ‘build the tree’ towards the desired end conditions.  Starting from a base position, shift the first link one step in either direction (clockwise and counterclockwise, forward and back, etc) and determine which one is closer to the end state, and saving that state.  Next, go to the next link and do the same thing, finding which direction a single step would provide a larger step towards the end goals.  When each link is tested this way, the whole operation is started again from the top, repeated until the end conditions are met or a timeout is reached.</p>
 
-Gradient Descent is another iterative kinematic model, which maps the entire achievable space of the system.  By rating each pose in a 2D or 3D grid, it's possible to trace through the map to find the ideal path or system state, although compared to other methods it is typically much more computationally expensive as there can be a lot of achievable poses that may not be realistic but still take up more than a small level of computation power and time.
+<p>Gradient Descent is another iterative kinematic model, which maps the entire achievable space of the system.  By rating each pose in a 2D or 3D grid, it’s possible to trace through the map to find the ideal path or system state, although compared to other methods it is typically much more computationally expensive as there can be a lot of achievable poses that may not be realistic but still take up more than a small level of computation power and time.</p>
 
-<img src="/img/IterativeKinematicSolver.png" alt="Iterative Kinematics Example" class="img-responsive"> 
+<p><img src="/img/IterativeKinematicSolver.png" alt="Iterative Kinematics Example" class="img-responsive" /></p>
+ 
             </div>
         </div>
     </div> <!-- row -->