Week 1


The first week I started to settle in the new work environment. Got to know the people I am going to be working with and got introduced to the new school. I started reading papers on the projects.
I also did research on animatronics and on the use of robots as an assistance in search and rescue operations.

Week 2


Started to work on a research plan. Did research on controllers used to control a set of servo motors from a computer. Worked on adding features to a software used to serve as an interface for robot-human interaction using MIMO displays.

Week 3


Finallized a research on controllers for servo motors and prepared a form with my co-workers to present a proposal to my asdviser reviewing which controllers were better to adquire for the project. My project got adjusted.

Week 4


Started working on haptic-aided robot motion planning. Read articles on Probabilistics Roadmaps, Random Sampling, and Haptic-Aided Motion Planning; and wrote summaries for them. Got introduced to the project and started to familiarize with the code implementation. Ran several times the current interface for Haptic-Aided Motion Planning.

Week 6


- Implemented Ajay's second proposed path-modifying algorithm. This algorithm takes a path, then for each one of the nodes it checks if they are collision-free or not. If the nodes are in collision, then the algorithm tries to push it to a collision-free configuration by walking in several random directions in C-Space. I implemented the algoirthm and put it in a method and created a class for it.
- Then I learned how to integrate the method with the rest of the system to run it and be able to test it.
- During testing I found and error in the system that was making the program ignore any specified path-modifying algorithm. Because of that, I was not able to test my method. Phil will be working on this error meanwhile I work on the generic method that I am also working on.
- Worked on my research plan and gave it a couple of final touches. Then submitted it for review to my mentors. When I received approval I formatted it to pdf using LaTex, and submitted it to Theresa.
- Added to my project the assignment of creating a generic path modifying method that will allow us to apply different modifications to each segment of nodes in a path.
- I discussed over a design for the generic method and worked over several high-level overviews over the algorithm to use. These overviews presented pseudo-code progresivelly going down in levels of abstractions.
- Implemented an actual C++ algorithm for the generic method and dicussed it with Phil and Lydia.
- They advised me to look into the code in the repository and study the different evaluators and variable operations that can be applied to paths. Then to try to used them.

Week 7


This week I started to work on the implementation of a generic path modifying method. This method will provide for a framework which allows to gather nodes of a path into different segments. Then apply different path modifying algorithms to each one of these segments, and evaluate the resulting path to determine if another method should be applied. So on Monday I studied the code stored in the code repository to decide which structures and functions I would use. For the NodeEvaluation Phase I used: class CollisionDetection, class DistanceMetrics, class Closest, class LocalPlanner These classes have functions that allow me to evaluate the connectivity of a node, and its collision status. The generic method has five sections which give the flexibility for different path-modifying behaviors. These sections are:
-NodeEvaluation
-SegmentBuilding
-SegmentEvaluation
-SegmentModification
-PathEvaluation
As a way to allow for changing behaviors, I decided to create template classes that would provide a template of how these sections should be implemented. These template classes will be derived by other classes, and these classes would provide their respective particular functionality to the different operations taken in these sections.
So I created six template classes:
1. Template_Segment: The nodes in a path will be grouped into different segments depending on their characteristics. The data structure in which the nodes will be stored will be a Segment. This class Template_Segment provides for the fundamental field and function declarations which are used in this structure. The classes that derive from Template_Segment then implement their own behavior to the Segment.
2. Template_NodeEvaluator: Offers the template structure and function declaration that can be applied to evaluate a node as valid or invalid.
3. Template_SegmentBuilder: This class decides in which segment to store a node depending on its node evaluation.
4. Template_SegmentEvaluation: To apply the most optimal modification to a segment, this segment must be evaluated first. This class analyzes a segment and marks it depending on its characteristic. This marks are used later on to decide on which modification algorithm to apply to the segment.
5. Template_SegmentModify: In this section, a segment is applied a particular modification behavior depending on the mark given to it.
6. Template_PathEvaluator: In this section we evaluate the path and decide if it is valid, or if we need to apply a different path modifying algorithm.

Each one of this template classes is allocated in a .h file.
The whole idea of having these template classes is to provide for flexibility and allow for the application of different behaviors. But how could we tell the program which behavior to use (which derivate classes to use ) without having to change the code implementation of the generic method? To answer that question I decided to create a class named EvaluatorProvider. This class takes a parameter. Depending on this parameter callType, and through a switch(), it creates instances of the right specified derivate classes and returns it to the generic method. The generic method then use these derivate classes to apply the specified behavior.
The plan is to have a series of template classes, and a set of derivate classes. Then have the EvaluatorProvider return the right set of derivate classes to the generic method depending on parameter read from xml.
The xml parameterization of this was not implemented this week because I started to work on an example of a path modifying strategy. I hardcoded the EvaluatorProvider to return a set of derivate classes which apply path-modification through taking nodes in collision and walking in random directions to find close free configurations and add them to the path. This method was suggested by student Ajay Challagalla. I worked on applying this method. Then integrated all my work to the external framework and compiled. Fixed the errors and I am ready to test it. I was not able to test it because external errors to the framework were found which impede my work from being executed. I will be working on fixing this errors and then I'll test my work to find internal errors.

Week 8


This week I spent most of my time debugging the program. I fixed some errors and incompatibilities existing in the code frame that handled class PathModify. class PathModify is the class from which all my path modifying functionality is called. Then I was able to concentrate on errors originating from inside PathModify. Right now I am working on an error that appears when the SegmentModification stage is executed. After this I'll proceed to debug erros in the PathEvaluation section. So far the functionality from sections NodeEvaluation, SegmentBuild, and SegmentEvaluation runs well. I tested it with the aid of VIZMO and gave good results. I created a path of my own which intersects an object in environment narrow.env PathModify detected all the invalid nodes and built the right number of segments that I intended with my implementation. I am still to test the SegmentModify section, but I will do it as soon as I fix an error which I discovered in my implementation of this section. I also started my Research Paper. I wrote my abstract and introduction.

Week 9


Week nine was what we call "crunch time!!". Deadlines were all closing up and most of us in the lab were working really hard for long periods of time. Luckily I think we all got good results in our work ready for Week 10's presentations.

Week 10


Week ten is the last week of this summer program. I have to say that the time went quickly. I have earned great experience working at this university and I had the opportunity to learn from the other members of the team. This week will be concluded by our final presentations and the final paper. On Thursday we have a farewell dinner, and on Firday we have the last poster presentation and awards ceremony.