Todo List

File cuiktransform.c

Integrate the CuikSuite with a proper 3D modeler such as blender.

Global FindSingularPoint (Tparameters *pr, unsigned int bID, Tatlas *a)

Stop the search if we end up in the other branch just by chance.

Global FindPointInOtherBranch (Tparameters *pr, unsigned int bID, double *phi, double **p, Tatlas *a)

Intoduce checks to see is we converged relatively close to the departing point. If we converge too far away we had better not use the the final point.

Global ProcessBifurcation (Tparameters *pr, unsigned int bID, TAtlasStatistics *ast, Tatlas *a)

Implement this!

Global InitHandC (Tparameters *pr, Tworld *wo, TDynamicSpace *ds)

Extend the HandC procedure to deal with

Global BuildAtlasFromPoint (Tparameters *pr, double *p, boolean simpleChart, TAtlasBase *w, Tatlas *a)

Make collision detection re-entrant so that we can use openMP with it This basically means to have as many collision detection structures as prallel threads.

Global SaveAtlas (Tparameters *pr, Tfilename *fname, Tatlas *a)

Save atlas (and charts) in binary format.

Global ADJUST_SA

Set ADJUST_SA as a parameter so that it can be set without re-compiling. This implies to add an 'scale' field to the AtlarRRT structure and to modify some function interfaces and the SaveAtlasRRT (and the load) accordingly.

Class TAtlasRRTStatistics

Switch to thread-save statistics before implementing a parallel version of the AtlasRRT.

Global PlotChart (Tparameters *pr, FILE *fcost, TJacobian *sJ, unsigned int xID, unsigned int yID, unsigned int zID, Tplot3d *p3d, Tchart *c)

Speed up this function caching the vertex projection on the manifold instead as recomputing them as many times as needed.

Global InitDynamicSpace (Tparameters *pr, boolean parallel, TJacobian *sJ, TAtlasBase *w, TDynamicSpace *ds)

Include the mass matrix and force defining functions as parametres. We will do it when the corresponding interface is clear.

Global Getxdot (Tparameters *pr, double *x, double *u, double *a, TDynamicSpace *ds)

Implement the unsimplification of derivatives.

Global EXPLORATION_RRT

Set this as a parameter and not as a compilation flag.

Class TRRTStatistics

Switch to thread-save statistics before implementing a parallel version of the RRT.

Global SaveRRT (Tfilename *fname, Trrt *rrt)

Save RRT in binary format.

Class Tscpolytope

Implement the conversions between Tpolytope and Tspolytope.

Global GetSPolytopeBoxSide (Tscpolytope *mp)

Frontier charts should be represented by balls and not by boxes.

Global APPROXIMATED_CHARTS_IN_GRADIENT

Verify that this results in actual speed up.

Global GradientSmooth (Tparameters *pr, unsigned int nCores, unsigned int maxIterations, boolean *sv, Tstatistics *stime, unsigned int *np, double ***point, TStepCost stepCost, TStepCostGradient stepCostGradient, TAtlasBase *w)

Implement a parallel version of the GradientSmooth function.

File energy.cpp

Remove this from the repository.

Global EQ_MIN_IN_CENTER

Just select the evaluation method that is better and remove the other.

Global NEWTON_WITHIN_RANGES

Remove this if box limits do not help at all

Global CuikNewtonSimp (Tparameters *p, double *x, TCuikSystem *cs)

Reduce the duplicity of code between CuikNewtonSimp and CuikNewtonInBox. This is not easy since CuikNewtonInBox includes lots of code to take into account box bondaries and inequalitites and code to convert from boxes in the original system to boxes in the simplified system at the beggining of the function and the revese change at the end of the function.

Global RANDOMNESS

Remove this in the final version. This is for debug only

File geom.h

Separate non-geometric functions fom the purely geometric ones.

Class TJacobian

Take advantage of the velocity flags for variables and equations to speed up the Jacobian evaluation.

File linear_constraint.h

It might be possible to joint into a single type Tequation and TLinearConstraint. Some of the functions in the simplex could be slightly solwer but we could simplify a little the CuikSuite structure.

Global PolynomialMonomial (Tmonomial *f)

Replace the term monomial by factor.

File cuikcad.c

Implement cuikcad.c.

File cuikworld2sdf.cpp

Test the generation of sdf joints from cuik joints.

Implement the generation of sdf sph-sph and sph-prs-sph joints.

Implement the cuikgazeboplayer. Probably as a trivial ROS node moving different degrees of freedom.

File cuikurdf2world.cpp

Integrate the urdf2world into ROS to use all the ROS tools. However, this means that the application would require a full ROS installation.

File cuikaddjacobian.c

Define tools to generate equation systems to detect particular singularities (end effector, actuator,...). These tools will be less flexible that the combined use of cuiksingequations and cuikaddjacobian but will be useful for most of the cases.

File cuikslam.c

Implement cuikslam.c. This implies to find a proper way to define the constraints between poses and between those and landmarks.

Global CheckCollision (boolean all, THTransform *tl, TLinkConf *def, THTransform *tlPrev, TLinkConf *defPrev, TworldCD *cd)

Implement link deformation in CD engines other than SOLID.

Class Tjoint

Right now only prismatic, spherical, revolute, universal and spherical-spherical joints are defined. Although it is not urgent, we have to define more types of joints: CYL_JOINT (cylindrical joint), and HEL_JOINT (helical joint).
To define a new type of joint, we have to define a new constructor, to to extend the GenerateJointEquations and the GenerateJointRangeEquations functions.

Global LINK_Connect

Automatically generate constraints from connection links (only for those with fixed length).

Connection links have no force model. If their length is variable we can add a linear force model, for instance. The problem is that the length is not direclty available and, thus, this force must be computed from upper levels (or at least the lenght must be provided).

Global InitDeformXLink (char *name, unsigned int forceModel, Tinterval *length, double stiffness, Tinterval *rest, Tinterval *force, double mass, double **iMatrix, THTransform *iFrame, Tlink *l)

Adjust the dynamic parameters according to the deformation.

Global InitPrismaticXLink (char *name, unsigned int forceModel, Tinterval *length, double stiffness, Tinterval *rest, Tinterval *force, double mass, double **iMatrix, THTransform *iFrame, Tlink *l)

Adjust the dynamic parameters according to the extension of the prismatic link.

Global COUPLE_ORIENTATION

Generalize the orientation constraint betwee tensegrity elements so that we can set a fixed rotation between them.

Global InitTensegrityFromFile (Tparameters *p, char *fn, Tworld *w)

Right now we use a link-based representation for tensegrities since it is clear and close to the representations used for parallel platforms. In this way, the integration of the tensegrities in the CuikSuite is relatively simpel. However this representation uses too many variables. We could think on implementing a particular type of representation for tensegrities based on representing only the coordinates of the tensegrity nodes. This will be more compact. However it introduces complexity in the translation from/to degrees of freedom and other related procedues. In this yet to implement representatoin we need coordinates (x,y,z) for the tensegrity nodes, the norm of the tensegrity elements l=||n_1-n_2|| (which can be fixed or variable) and auxiliary variable 'd' such that l*d=l-r, with r the rest length. with this variable the force of an element is f=k*d*n_1-k*d*n_2, with n1, n2 the coordiantes of the connected nodes. The main issue with this representation is the absence of loops which is a core-assumption in the CuikSuite.

File Serial6RRX60.world

Introduce the range limitations for each one of the degrees of freedom of the Staubli RX60.

Directory examples/WSSingularities

Develop tools to automatically generate the equations for the singularity-related problems.