diff --git a/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn.gif b/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn.gif deleted file mode 100644 index a1dc7dd..0000000 Binary files a/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn.gif and /dev/null differ diff --git a/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn1.gif b/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn1.gif deleted file mode 100644 index a481a9f..0000000 Binary files a/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn1.gif and /dev/null differ diff --git a/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn2.gif b/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn2.gif deleted file mode 100644 index 14e9638..0000000 Binary files a/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn2.gif and /dev/null differ diff --git a/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn3.gif b/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn3.gif deleted file mode 100644 index 80b7b58..0000000 Binary files a/blogweb/gsoc14/aimilitaru/images/CodeCogsEqn3.gif and /dev/null differ diff --git a/blogweb/gsoc14/aimilitaru/images/debug_1.png b/blogweb/gsoc14/aimilitaru/images/debug_1.png new file mode 100644 index 0000000..aac1114 Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/debug_1.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/debug_2.png b/blogweb/gsoc14/aimilitaru/images/debug_2.png new file mode 100644 index 0000000..9fbb392 Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/debug_2.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/debug_4.png b/blogweb/gsoc14/aimilitaru/images/debug_4.png new file mode 100644 index 0000000..fa19901 Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/debug_4.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/debug_5.png b/blogweb/gsoc14/aimilitaru/images/debug_5.png new file mode 100644 index 0000000..6015dbe Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/debug_5.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/latex1.jpg b/blogweb/gsoc14/aimilitaru/images/latex1.jpg deleted file mode 100644 index 99cc0eb..0000000 Binary files a/blogweb/gsoc14/aimilitaru/images/latex1.jpg and /dev/null differ diff --git a/blogweb/gsoc14/aimilitaru/images/result.png b/blogweb/gsoc14/aimilitaru/images/result.png new file mode 100644 index 0000000..e036733 Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/result.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/result10.png b/blogweb/gsoc14/aimilitaru/images/result10.png new file mode 100644 index 0000000..1ac0887 Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/result10.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/result_overlap.png b/blogweb/gsoc14/aimilitaru/images/result_overlap.png new file mode 100644 index 0000000..8a3c5ee Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/result_overlap.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/target.png b/blogweb/gsoc14/aimilitaru/images/target.png new file mode 100644 index 0000000..b04a25a Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/target.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/weight1.png b/blogweb/gsoc14/aimilitaru/images/weight1.png new file mode 100644 index 0000000..0e8e399 Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/weight1.png differ diff --git a/blogweb/gsoc14/aimilitaru/images/weight2.png b/blogweb/gsoc14/aimilitaru/images/weight2.png new file mode 100644 index 0000000..f43ec26 Binary files /dev/null and b/blogweb/gsoc14/aimilitaru/images/weight2.png differ diff --git a/blogweb/gsoc14/aimilitaru/status.rst b/blogweb/gsoc14/aimilitaru/status.rst index a0320a9..a3efb10 100644 --- a/blogweb/gsoc14/aimilitaru/status.rst +++ b/blogweb/gsoc14/aimilitaru/status.rst @@ -57,7 +57,106 @@ My status updates T\. Vetter and V. Blanz, A Morphable Model For The Synthesis Of 3D Faces, Max-Planck-Institut, Tubingen, Germany +.. blogpost:: + :title: Rigid and Non-Rigid Transformation ( Second phase ) + :author: aimilitaru + :date: 17-07-2014 + + * **Introduction** + + In the previous phase, it was presented how to obtain a statistical model from a set of face-meshes. The next step in our project is to "*match*" the mean face of the database, with the face of a random person, like the one in the picture below: + + + .. image:: images/target.png + :width: 650px + :height: 300px + :align: center + + + The matching is done by applying alternatively the following methods. + + + + * **Rigid Registration** + + + + This method is very similar to the Iterative Closest Point Cloud algorithm, because the goal is to estimate a rotation matrix and a translation vector that would move the average face to an optimal position, near the face of the kinect. Basically, it is required to minimize the error :math:`\epsilon = \sum ||\vec {y} - (R \cdot \vec{x} + \vec{t})||^2` and this is done by calculating the solution of this system in the least square sense. In order to calculate this solution, the system is first linearized using the Jacobian matrix. + + Of course this process is applied iteratively, and below are presented a few stages of positioning of the model over the scan: + + .. image:: images/debug_1.png + :width: 650px + :height: 300px + :align: center + + + .. image:: images/debug_2.png + :width: 650px + :height: 300px + :align: center + + + .. image:: images/debug_4.png + :width: 650px + :height: 300px + :align: center + + + .. image:: images/debug_5.png + :width: 650px + :height: 300px + :align: center + + + + + + * **Non-Rigid Registration** + + + + Once the model is roughly aligned, we need to modify the shape of the model to match the face from the scan. For this we make use of the eigenvectors computed in the previous phase and we calculate the optimal solution of this system: :math:`\vec {y} = P \cdot \vec{d} + \vec{model}`, where :math:`P` is the matrix of eigenvectors, :math:`\vec{model}` is the current form of the model and :math:`\vec{d}` is the vector of basis coefficients that need to be determined. + However, there is on more constraint to be applied and that is to minimize the sum :math:`\sum_i \frac{d_i}{\sigma_i}`, where :math:`\sigma_i` is the eigenvalue of the corresponding eigenvector. Therefore, to the Jacobian matrix of this system, we need to add a diagonal matrix with :math:`\frac{1}{\sigma_i}` on the diagonal and multiplied by a certain weight. + + The purpose of this regualrization is to determine to what degree the face should be deformed. The eigenvectors are stored in the :math:`P` matrix in decreasing order according to their eigenvalues and their position in this sorting order determines whether they have a greater or a smaller influence on the shaping of the model. When the model is mostly overlapping with the face in the scan, more information can be drawn about the final figure, hence the weight specified above should be smaller . On the other hand, if the model is not yet aligned with the scan, the deforming should be smaller and thus the weight should be bigger. Below you can see how the model looks for several values of the weight: + + .. image:: images/weight1.png + :width: 650px + :height: 300px + :align: center + + .. image:: images/weight2.png + :width: 650px + :height: 300px + :align: center + Notice that the shaping process tends to return the same effect if the weight of the regularizing constraint exceeds a certain value. + * **Results** + + + + As mentioned above, these functions are applied alternatively for a few number of times, and the following results were obtained: + + .. image:: images/result.png + :width: 650px + :height: 300px + :align: center + + The above picture was obtained after one iteration and the following one after 10: + + .. image:: images/result10.png + :width: 650px + :height: 300px + :align: center + + Also, below you can observe the precision of this method, the black figure representing the final version of the model and the green one representing the point cloud of the face: + + .. image:: images/result_overlap.png + :width: 650px + :height: 300px + :align: center + diff --git a/blogweb/gsoc14/jdbarros/entries/figures/Middlebury_dataset.png b/blogweb/gsoc14/jdbarros/entries/figures/Middlebury_dataset.png new file mode 100644 index 0000000..d2bcd6a Binary files /dev/null and b/blogweb/gsoc14/jdbarros/entries/figures/Middlebury_dataset.png differ diff --git a/blogweb/gsoc14/jdbarros/figures/compact_ca.png b/blogweb/gsoc14/jdbarros/entries/figures/compact_ca.png similarity index 100% rename from blogweb/gsoc14/jdbarros/figures/compact_ca.png rename to blogweb/gsoc14/jdbarros/entries/figures/compact_ca.png diff --git a/blogweb/gsoc14/jdbarros/figures/conventional_ca.png b/blogweb/gsoc14/jdbarros/entries/figures/conventional_ca.png similarity index 100% rename from blogweb/gsoc14/jdbarros/figures/conventional_ca.png rename to blogweb/gsoc14/jdbarros/entries/figures/conventional_ca.png diff --git a/blogweb/gsoc14/jdbarros/figures/disp_cand_selection.png b/blogweb/gsoc14/jdbarros/entries/figures/disp_cand_selection.png similarity index 100% rename from blogweb/gsoc14/jdbarros/figures/disp_cand_selection.png rename to blogweb/gsoc14/jdbarros/entries/figures/disp_cand_selection.png diff --git a/blogweb/gsoc14/jdbarros/entries/status_06_24.rst b/blogweb/gsoc14/jdbarros/entries/status_06_24.rst new file mode 100644 index 0000000..2f8e41c --- /dev/null +++ b/blogweb/gsoc14/jdbarros/entries/status_06_24.rst @@ -0,0 +1,56 @@ +.. blogpost:: + :title: 1. Reduction of computational redundancy in cost aggregation in stereo matching. + :author: jilliam + :date: 21-06-2014 + + **INTRODUCTION** + + A stereo image pair can be used to estimate the depth of a scene. To do so, it is necessary to perform pixel matching and find the correspondences in both images. Different methods for stereo correspondence have been proposed and they are classified in two classes: + + - Correlation-based algorithms: Produce a dense set of correspondences. + + - Feature-based algorithms: Produce a sparse set of correspondences. + + Additionally, correlation-based algorithms are usually classified in two main groups, local (window-based) or global algorithms. However, some methods do not fit into any group, and are classified in between them. + + The current work is based on correlation-based algorithms, more espefically local and window based-methods, intended for applications where a dense and fast output is required. + + The input of the algorithm are two calibrated images, i.e. the camera geometry is known. The images are also rectified in order to limit the correspondence to a 1D search. + + **CORRESPONDENCE ESTIMATION** + + The general methodology for stereo vision local approaches can be summarized as follows. An energy cost is computed for every pixel p by using the reference and d-shifted right images: + + .. math:: e \left(p,d \right) = min \left(|I_{l}(x,y)-I_{r}(x-d,y)|, \sigma \right) + :label: eq11 + + Then, the aggregated cost is computed by an adaptive sum of the per-pixel cost: + + .. math:: E(p,d) = \dfrac{\displaystyle \sum_{q \in N(p)}w(p,q)e(q,d)}{\displaystyle \sum_{q \in N(p)}w(p,q)} + :label: eq12 + + Finally, a Winner-Takes-All method is used to find the best of all the disparity hypothesis: + + .. math:: d(p) = argmin\{ E(p,d), d \in [ 0,..,D-1 ] \} + :label: eq13 + + This whole process is complex and time consuming since it is repeated for every hypothesis d. + A representation of the conventional approaches can be observed in next figure [Min1]_. + + .. image:: figures/conventional_ca.png + :height: 240px + :align: center + + Min et al. [Min1]_ introduced a new methodology to reduce the complexity, by finding a compact representation of the per-pixel likelihood, assuming that low values do not provide really informative support. In this case, only a pre-defined number of disparity candidates per pixel are selected to perform the cost aggregation step. The subset of disparity hypotheses correspond to the local maxima points in the profile of the likelihood function, previously pre-filtered to reduce the noise, as shown in the following example: + + .. image:: figures/disp_cand_selection.png + :height: 240px + :align: center + + The disparity hypotheses estimation and cost aggregation processes proposed by Min et al. are depicted in the next figure, where Sc is the subset of disparity hypothesis with size Dc: + + .. image:: figures/compact_ca.png + :height: 240px + :align: center + + .. [Min1] Min, D., Lu, J., & Do, M. N. "A revisit to cost aggregation in stereo matching: How far can we reduce its computational redundancy?." In IEEE International Conference on Computer Vision (ICCV), 2011 (pp. 1567-1574). diff --git a/blogweb/gsoc14/jdbarros/entries/status_06_28.rst b/blogweb/gsoc14/jdbarros/entries/status_06_28.rst new file mode 100644 index 0000000..f657be5 --- /dev/null +++ b/blogweb/gsoc14/jdbarros/entries/status_06_28.rst @@ -0,0 +1,47 @@ +.. blogpost:: + :title: 2. Implementation of local-based approach for stereo matching + :author: jilliam + :date: 28-06-2014 + + **INTRODUCTION** + + In this post, I will briefly describe the current state of the stereo module and the new features added. + + Currently, the stereo module encompass two matching local-based algorithms: + 1. Block-based algorithm, which is programed using the Box-Filtering algorithm proposed in [McDonnell81]_. + 2. Adaptive Cost 2-pass Scanline Optimization, presented in [Wang06]_. + Both methods use the Sum of Absolute Differences (SAD) as the dissimilarity measure. + + As mentioned in the previous blog, the first objective of the present project is to implement the local-based approach proposed in [Min1]_, for dense correspondence estimation in a pair of grayscale rectified images with an efficient cost aggregation step. Additionally, the cost aggregation step in based on the method presented in [Yoon06]_, where the weighting function uses a similarity measure based on the color and spatial distances. + + **DETAILS** + + In order to do so, a new class CompactRepresentationStereoMatching was created in the stereo module. This class inherits from class GrayStereoMatching, which in turns inherits from class StereoMatching, since some pre and post-processing methods are re-implemented. + The new class has five member functions with public access: setRadius, set FilterRadius and setNumDispCandidates, setGammaS, setGammaC, which set three data members of type int (radius, filter_radius and num_disp_candidates) and two of type double (gamma_c and gamma_s) with private access, as well as implementing the virtual method compute_impl. + + **radius** corresponds to the radius of the cost aggregation window, with default value equal to 5. + + **filter_radius** corresponds to the radius of the box filter used for the computation of the likelihood function. The default value is 5. + + **num_disp_candidates** is the number of the subset of the disparity hypotheses used for the cost aggregation. The default value is 60. + + **gamma_c** is the spatial bandwidth used for cost aggregation based on adaptive weights. The default value is 15. + + **gamma_s** is the color bandwidth used for cost aggregation based on adaptive weights. The default value is 25. + + Similarly to the previous methods, the current class is based on the SAD matching function, and it estimates the per-pixel cost efficiently using the Box-Filtering algorithm. + + To test the algorithm, the Middlebury stereo benchmark (http://vision.middlebury.edu/stereo/) dataset is going to be used. + + .. image:: figures/Middlebury_dataset.png + :height: 240px + :align: center + + .. [McDonnell81] McDonnell, M. J. "Box-filtering techniques". Computer Graphics and Image Processing 17.1, 65-70, 1981. + + .. [Wang06] Wang, Liang, et al. "High-quality real-time stereo using adaptive cost aggregation and dynamic programming." 3D Data Processing, Visualization, and Transmission, Third International Symposium on. IEEE, 2006. + + .. [Yoon06] K.-J. Yoon and I.-S. Kweon. “Locally Adaptive Support-Weight Approach for Visual Correspondence Search”. In Proceedings of Conference on Computer Vision and Pattern Recognition (CVPR), 924–931, 2005. + + + diff --git a/blogweb/gsoc14/jdbarros/status.rst b/blogweb/gsoc14/jdbarros/status.rst index 624d032..756fc92 100644 --- a/blogweb/gsoc14/jdbarros/status.rst +++ b/blogweb/gsoc14/jdbarros/status.rst @@ -5,58 +5,5 @@ My status updates :nr_days: 60 :author: jilliam - -.. blogpost:: - :title: Reduction of computational redundancy in cost aggregation in stereo matching. - :author: jilliam - :date: 21-06-2014 - - **INTRODUCTION** - A stereo image pair can be used to estimate the depth of a scene. To do so, it is necessary to perform pixel matching and find the correspondences in both images. Different methods for stereo correspondence have been proposed and they are classified in two classes: - - Correlation-based algorithms: Produce a dense set of correspondences. - - Feature-based algorithms: Produce a sparse set of correspondences. - - Additionally, correlation-based algorithms are usually classified in two main groups, local (window-based) or global algorithms. However, some methods do not fit into any group, and are classified in between them. - - The current work is based on correlation-based algorithms, more espefically local and window based-methods, intended for applications where a dense and fast output is required. - - The input of the algorithm are two calibrated images, i.e. the camera geometry is known. The images are also rectified in order to limit the correspondence to a 1D search. - - **CORRESPONDENCE ESTIMATION** - The general methodology for stereo vision local approaches can be summarized as follows. An energy cost is computed for every pixel p by using the reference and d-shifted right images: - - .. math:: e \left(p,d \right) = min \left(|I_{l}(x,y)-I_{r}(x-d,y)|, \sigma \right) - :label: eq11 - - Then, the aggregated cost is computed by an adaptive sum of the per-pixel cost: - - .. math:: E(p,d) = \dfrac{\displaystyle \sum_{q \in N(p)}w(p,q)e(q,d)}{\displaystyle \sum_{q \in N(p)}w(p,q)} - :label: eq12 - - Finally, a Winner-Takes-All method is used to find the best of all the disparity hypothesis: - - .. math:: d(p) = argmin E(p,d), d \in {[ 0,..,D-1 ]} - :label: eq13 - - This whole process is complex and time consuming since it is repeated for every hypothesis d. - A representation of the conventional approaches can be observed in next figure [Min1]_. - - .. image:: figures/conventional_ca.png - :height: 240px - :align: center - - Min et al. [Min1]_ introduced a new methodology to reduce the complexity, by finding a compact representation of the per-pixel likelihood, assuming that low values do not provide really informative support. In this case, only a pre-defined number of disparity candidates per pixel are selected to perform the cost aggregation step. The subset of disparity hypotheses correspond to the local maxima points in the profile of the likelihood function, previously pre-filtered to reduce the noise, as shown in the following example: - - .. image:: figures/disp_cand_selection.png - :height: 240px - :align: center - -The disparity hypotheses estimation and cost aggregation processes proposed by Min et al. are depicted in the next figure, where Sc is the subset of disparity hypothesis with size Dc: - - .. image:: figures/compact_ca.png - :height: 240px - :align: center - - .. [Min1] Min, D., Lu, J., & Do, M. N. "A revisit to cost aggregation in stereo matching: How far can we reduce its computational redundancy?." In IEEE International Conference on Computer Vision (ICCV), 2011 (pp. 1567-1574). - - +status_06_24 +status_06_28 diff --git a/blogweb/gsoc14/kdesingh/images/box.png b/blogweb/gsoc14/kdesingh/images/box.png new file mode 100644 index 0000000..dedc091 Binary files /dev/null and b/blogweb/gsoc14/kdesingh/images/box.png differ diff --git a/blogweb/gsoc14/kdesingh/images/box_image.png b/blogweb/gsoc14/kdesingh/images/box_image.png new file mode 100644 index 0000000..aa54e1d Binary files /dev/null and b/blogweb/gsoc14/kdesingh/images/box_image.png differ diff --git a/blogweb/gsoc14/kdesingh/images/cylinder.png b/blogweb/gsoc14/kdesingh/images/cylinder.png new file mode 100644 index 0000000..5c60987 Binary files /dev/null and b/blogweb/gsoc14/kdesingh/images/cylinder.png differ diff --git a/blogweb/gsoc14/kdesingh/images/cylinder_image.png b/blogweb/gsoc14/kdesingh/images/cylinder_image.png new file mode 100644 index 0000000..1048d3a Binary files /dev/null and b/blogweb/gsoc14/kdesingh/images/cylinder_image.png differ diff --git a/blogweb/gsoc14/kdesingh/images/plane.png b/blogweb/gsoc14/kdesingh/images/plane.png new file mode 100644 index 0000000..7bb5f97 Binary files /dev/null and b/blogweb/gsoc14/kdesingh/images/plane.png differ diff --git a/blogweb/gsoc14/kdesingh/images/plane_image.png b/blogweb/gsoc14/kdesingh/images/plane_image.png new file mode 100644 index 0000000..c18c797 Binary files /dev/null and b/blogweb/gsoc14/kdesingh/images/plane_image.png differ diff --git a/blogweb/gsoc14/kdesingh/images/sphere.png b/blogweb/gsoc14/kdesingh/images/sphere.png new file mode 100644 index 0000000..ccf941d Binary files /dev/null and b/blogweb/gsoc14/kdesingh/images/sphere.png differ diff --git a/blogweb/gsoc14/kdesingh/images/sphere_image.png b/blogweb/gsoc14/kdesingh/images/sphere_image.png new file mode 100644 index 0000000..fe3f009 Binary files /dev/null and b/blogweb/gsoc14/kdesingh/images/sphere_image.png differ diff --git a/blogweb/gsoc14/kdesingh/status.rst b/blogweb/gsoc14/kdesingh/status.rst index 8ecc723..87eae57 100644 --- a/blogweb/gsoc14/kdesingh/status.rst +++ b/blogweb/gsoc14/kdesingh/status.rst @@ -190,4 +190,47 @@ My status updates Next post will have the details of how GRSD results are and how they differentiate the characteristics of two surfaces. GRSD code from the author will be integrated into the PCL code base. We also plan to categorize the pipeline into modules that fit into the PCL code base as features, surface and segmentation sections. These information will be posted in the next post. - + + + +.. blogpost:: + :title: GRSD Descriptor computation and analysis + :author: kdesingh + :date: 28-07-2014 + + Global Radius-based surface descriptor concatenates the RSD descriptor as discussed in the previous post to represent the complete object. + GRSD gives a good description of the 3D shape of the object. Below are the set of objects and its GRSD descriptors i.e. histograms. I have + used University of Washington's "Large scale RGBD dataset" for the experiments. + + For an object whose surface is planar but has 2 different planes in the view + .. image:: images/box_image.png + :height: 240px + .. image:: images/box.png + :height: 200px + + + For an object whose surface is planar but has 1 planes in the view + .. image:: images/plane_image.png + :height: 240px + .. image:: images/plane.png + :height: 200px + + For an object whose surface is spherical + .. image:: images/sphere_image.png + :height: 240px + .. image:: images/sphere.png + :height: 200px + + For an object whose surface is cylinderical but doesn't have any planar surface in view + .. image:: images/cylinder_image.png + :height: 240px + .. image:: images/cylinder.png + :height: 200px + + It can be seen that all the descriptors are different from eachother. Planes and box surfaces are similar as the surface characteristics + are similar in this case. + Both GRSD and RSD are pushed into the pcl-trunk for people to use. The test files for these two features are also included in the trunk + for the basic usage of the same. + + Currently working on the NURBS for small surface patches. Since NURBS are already available in PCL we will be looking at how to tailor the + same for our needs. After this we plan to work on the features that compute the relationship between the surface patches. diff --git a/blogweb/gsoc14/mgesto/all.rst b/blogweb/gsoc14/mgesto/all.rst index 4068290..0cd8beb 100644 --- a/blogweb/gsoc14/mgesto/all.rst +++ b/blogweb/gsoc14/mgesto/all.rst @@ -1,5 +1,5 @@ -All blog posts for My_Name +All blog posts for Manuel Gesto ----------------------------- .. blogbody:: - :author: my_username + :author: Manuel_Gesto diff --git a/blogweb/gsoc14/mgesto/index.rst b/blogweb/gsoc14/mgesto/index.rst index 16bd64d..0e6b1c2 100644 --- a/blogweb/gsoc14/mgesto/index.rst +++ b/blogweb/gsoc14/mgesto/index.rst @@ -1,20 +1,20 @@ -My_name +Manuel Gesto ========== -:email: xyz@xyz.com -:project: What I will be doing this summer -:mentor: +:email: mgesto@usal.es +:project: Object Discovery in Kinfu Data +:mentor: Federico Tombari About me -------- -Hello World +I am a Phd student that will be working on GSOC. Recent status updates --------------------- .. blogbody:: - :author: my_username - :nr_posts: 5 + :author: Manuel_Gesto + :nr_posts: 4 diff --git a/blogweb/gsoc14/mgesto/status.rst b/blogweb/gsoc14/mgesto/status.rst index 4d8e993..9829bee 100644 --- a/blogweb/gsoc14/mgesto/status.rst +++ b/blogweb/gsoc14/mgesto/status.rst @@ -3,12 +3,83 @@ My status updates .. blogbody:: :nr_days: 60 - :author: my_username + :author: Manuel_Gesto +.. blogpost:: + :title: Object discovery in KINFU DATA (First post) + :author: Manuel_Gesto + :date: 30-07-2014 + * **Introduction** + + The principal goal of this project will be implement the algorithm and app developed in: + + -Fei-Fei, L., Karpathy, A., Miller, S."Object discovery Via Shape Analysis". + + + This automatic object discovery will be useful for robotics or autonomous vehicles and + it will be able to find different class of objects. This new approach compares different + parameters of an object to classify it into a class. We can explain the function of this + approach by giving a simple example: if we want to find a glass into an unknown room, we cannot + have a model of all the glasses in the world. But, we can have a number of parameters about the + shape that define the common parts of the glasses. + + The parameters that defined a object is based on the: "Objectness measures" part in the paper. This + is the core of the app and the most important part. And probably a good part to begin to code because is + quite easy to code. + + + + .. blogpost:: - :title: Test post - :author: my_username - :date: 25-04-2010 + :title: First implementation of Code "Objectness measures" (Second post) + :author: Manuel_Gesto + :date: 30-07-2014 + + * **Introduction** + + I begin with main part of the code, and probably the most easy to implement. In this part I write the code + to make this measures for each Point Cloud. The input in the code is a point cloud (or set of pointclouds) and the output a vector + with the values of the resultant measure. To simplify the code part and the use of this for other aplications, + this part is separated from the segmentation, also if anyone want to use other segmentation that the proposed in + the paper is usefull. + + + * **"Objectnes measures"** + We have 5 different measures: + + - Compactness: This measure looks into how compact is a object. Search the minimum bounding sphere + that contains all the surface of the mesh of the pointcloud. + + - Symmetry: This measure analyze the reflective symmetry along the three principal axes, based on the + eigenvalues of the scatter matrix. + + - Smoothness: This measure evaluate the quality of the points of the segments, if the segments have points + uniform spread around it, this will score high, if have spread points this will be have a low score. + + - Local Convexity: This measure determine the convexity of each polygon edge in the mesh of the point cloud, + and score each segment by the percentage of its edges which are convex. + + - Global Convexity: This measure is generated by a convex hull, and after that a mean distance + between the points and the convex hull is recorded to create this measure. + - Test post + * **"Future Work"** + + In the future work, I need to implement the segmentation to give data to measure the objects and test this code. + + Also, there is one measure missing, one that use all the segments in diferent scenes to make a better clasification. + This is the "recurence", but this depends on the on the number of scenes and segments, this need the segmentation before + and analyze the number of similar segments in the objects in all scenes. Objects with similar segments should be in the + same category. + + + +.. blogpost:: + :title: Second implementation of Code "Segmentation and creation of object candidates" (Third post) + :author: Manuel_Gesto + :date: 30-07-2014 + + * **Introduction** + + I am working on it, This is based on the Segmentation proposed by y Felzenszwalb and Huttenlocher. diff --git a/blogweb/gsoc14/mschoeler/all.rst b/blogweb/gsoc14/mschoeler/all.rst index d07b55c..d14ab2f 100644 --- a/blogweb/gsoc14/mschoeler/all.rst +++ b/blogweb/gsoc14/mschoeler/all.rst @@ -1,5 +1,5 @@ All blog posts for Markus Schoeler ------------------------------ +---------------------------------- .. blogbody:: :author: mschoeler diff --git a/blogweb/gsoc14/mschoeler/images/animal.png b/blogweb/gsoc14/mschoeler/images/animal.png new file mode 100644 index 0000000..40f8680 Binary files /dev/null and b/blogweb/gsoc14/mschoeler/images/animal.png differ diff --git a/blogweb/gsoc14/mschoeler/index.rst b/blogweb/gsoc14/mschoeler/index.rst index f7c21ec..fd69232 100644 --- a/blogweb/gsoc14/mschoeler/index.rst +++ b/blogweb/gsoc14/mschoeler/index.rst @@ -1,5 +1,5 @@ Markus Schoeler -========== +=============== :email: mschoeler@gwdg.de :project: Automated benchmark generation for object-part segmentation @@ -10,7 +10,7 @@ About me I am a PhD student at the University of Goettingen - Germany. My research interests include computer vision (most specifically object / part recognition) as well as machine learning. I have been heavily working with PCL and OpenCV in my research. Project Description --------- +------------------- This project consists of two parts: First, implementation of the paper [Stein et al. accepted for CVPR 2014]. The focus of this segmentation is getting nameable parts of objects for e.g. robot applications (for instance the handle of a hammer to pick it up or the head, hands, ... of a human). Second, automated generation of artificial scenes to create a unit-test/benchmarking functionality for 3D segmentation. I will implement a shape generator to dynamically assemble these scenes. Recent status updates diff --git a/blogweb/gsoc14/mschoeler/status.rst b/blogweb/gsoc14/mschoeler/status.rst index 4ffbb28..8cffe24 100644 --- a/blogweb/gsoc14/mschoeler/status.rst +++ b/blogweb/gsoc14/mschoeler/status.rst @@ -5,11 +5,21 @@ My status updates :nr_days: 60 :author: Markus - +.. blogpost:: + :title: Implementation of the shape generator + :author: Markus + :date: 07-08-2014 + + The work on the lccp implementation is mainly done and the pull request is awaiting its approvel. Thanks a lot for the help of the pcl community (especially Sergey and Victor). Thanks to your comments the lccp algorithm is now in a much better shape. + Talking about shapes: The next milestone in this GSOC project is the implementation of a shape generator which can be used to create various labeled scenes which can be used to create unit tests or benchmarks for part and/or object segmentation algorithms. I have written a big part of the code already. Now the question is: To which module of pcl should this generator go? I think about putting it into the geometry module. Any comment on this is more than welcome! The next image shows an assembled animal-like object which has been generated from simple geometric shapes (mainly geons). + + .. image:: images/animal.png + :align: center + .. blogpost:: :title: First post - LCCP algorithm implementation :author: Markus - :date: 16-06-2014 + :date: 06-16-2014 Hello everybody, this is my first blog post to this project. The last weeks I have been busy implementing the LCCP algorithm in PCL. The algorithm can be used to split a point cloud into regions which are isolated by concave boundaries to all other regions. It turns out that this is a highly valuable segmentation as it often retrieves (bottom-up!) nameable parts like handles, heads and so on. Especially robotic applications may find this useful. Together with Jeremie I will introduce it at this year's CVPR 2014 conference (S. C. Stein, M. Schoeler, J. Papon, F. Woergoetter: Object Partitioning using Local Convexity). We will have a poster next Tuesday afternoon. So if you are around, you are more than welcome to visit us there. In the meantime I hope I get the pull request through, so that everybody interested can play around with the algorithm. It will be located in the segmentation module. There is also an example pcl\_example\_lccp\_segmentation. To get you interested the following image shows an example of the segmentation. As you can see all parts can be easily named. diff --git a/blogweb/gsoc14/sanurag/images/MortonCode.png b/blogweb/gsoc14/sanurag/images/MortonCode.png new file mode 100644 index 0000000..3b0d5f6 Binary files /dev/null and b/blogweb/gsoc14/sanurag/images/MortonCode.png differ diff --git a/blogweb/gsoc14/sanurag/images/OctreeBuild.png b/blogweb/gsoc14/sanurag/images/OctreeBuild.png new file mode 100644 index 0000000..4124002 Binary files /dev/null and b/blogweb/gsoc14/sanurag/images/OctreeBuild.png differ diff --git a/blogweb/gsoc14/sanurag/images/QuadTree.png b/blogweb/gsoc14/sanurag/images/QuadTree.png new file mode 100644 index 0000000..e259677 Binary files /dev/null and b/blogweb/gsoc14/sanurag/images/QuadTree.png differ diff --git a/blogweb/gsoc14/sanurag/index.rst b/blogweb/gsoc14/sanurag/index.rst index 16bd64d..4112905 100644 --- a/blogweb/gsoc14/sanurag/index.rst +++ b/blogweb/gsoc14/sanurag/index.rst @@ -1,22 +1,24 @@ -My_name -========== +Anurag Soni +================== -:email: xyz@xyz.com -:project: What I will be doing this summer -:mentor: +:email: sonianurag099@gmail.com +:project: OpenCL Module for PCL +:mentor: Alvaro Arizaga About me -------- -Hello World +I am undergraduate student at Birla Institute of Technology, India. + +Project Description +------------------- +OpenCL Module for PCL is one of the attempts to increase the user productivity by increasing real time performance of algorithms. Over the years, computers/machines are expected to perform fast for computationally intensive application need. Use of Many-Core (GPU, MIC) and multi core CPU can satisfy high performance need of scientific and engineering applications. By using OpenCL, we can run PCL algorithms on heterogeneous platforms and can achieve higher throughput. Recent status updates --------------------- .. blogbody:: - :author: my_username - :nr_posts: 5 - - + :author: sonianurag + :nr_posts: 1 .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. .. diff --git a/blogweb/gsoc14/sanurag/status.rst b/blogweb/gsoc14/sanurag/status.rst index 4d8e993..3e371ea 100644 --- a/blogweb/gsoc14/sanurag/status.rst +++ b/blogweb/gsoc14/sanurag/status.rst @@ -3,12 +3,57 @@ My status updates .. blogbody:: :nr_days: 60 - :author: my_username + :author: anurag .. blogpost:: :title: Test post - :author: my_username - :date: 25-04-2010 + :author: anurag + :date: 08-08-2014 + + * **Introduction** + Point cloud library (PCL) is a collection of algorithms which can be used from simple computer vision applications (filtering, object recognition) to highly computationally expensive machine learning applications. PCL is used today in various fields like robotics, gaming, entertainment, computer vision, medical etc. PCL is cross-platform library, and can be used from Desktop to mobile platforms. To simplify development, PCL is separated into several modules like filtering, features, registration etc. These modules have algorithms which are computationally expensive and from them real time performance is required. + +OpenCL Module for PCL is one among the others attempt which are trying to increase the user productivity by increasing real time performance of algorithms. The goal of this GSOC Project is to optimize PCL modules using OpenCL so that these optimized modules can be used on various heterogeneous platforms. + +For implementing an OpenCL algorithm, we have to allocate the memory to device, run the kernel and get back the results from device to host. We have implemented a common platform Utils inside OCL module which can be used by different algorithms for memory allocation and running the kernel. Utils also take care of different point types of PCL library. For different point type we are not able to define structure for all point types inside OpenCL kernel. This module takes the point type as an argument and allocates memory according to that and removes the necessity of defining structure inside kernel. + +The most important two modules which are used mostly inside PCL library are filtering and searching. During this summer we have optimized some filtering algorithms and wrote the whole octree based searching method using OpenCL which is used in almost all PCL modules. We have also optimized the tracking library which uses particle filtering based tracker to track the object and heavily depends on searching and filtering modules. + +* **Searching Module** + +There are two known methods for optimizing octree building and searching. One is Bottom to top approach and another is Top-Down approach. Both of these methods are dependent on Space Filling Curves (Morton Codes). Morton Codes simplify the problem by representing the 3D points in single format (Morton code). It first chooses the order in which the leaf nodes (each corresponding to one object) appear in the tree, and then generating the internal nodes in a way that respects this order. We generally want objects that located close to each other in 3D space to also reside nearby in the hierarchy, so a reasonable choice is to sort them along a space-filling curve. + +We have used Top-Down approach in our implementation because it is faster than Bottom to Top approach and easy to implement on heterogeneous devices. The octree building is divided into following steps: + +1). **Morton Code Generation:** The space filling curve is defined in terms of Morton codes. To calculate a Morton code for the given 3D point, we start by looking at the binary fixed-point representation of its coordinates, as shown in Figure 1. First, we convert the floating point coordinates into 10 bit integer coordinate. Then we expand each coordinate inserting two “gaps” after each bit, after that, we interleave the bits of all three coordinates together to form a single binary number. If we step through the Morton codes obtained this way in increasing order, we are effectively stepping along the Z-order curve in 3D which is also called octree (a 2D representation is shown on the right-hand side of the Figure 1). In practice, we can determine the order of the leaf nodes by assigning a Morton code for each object and then sorting the objects accordingly. + +.. image:: images/MortonCode.png + :width: 908px + :height: 628px + :align: center + +.. image:: images/QuadTree.png + :width: 554px + :height: 454px + :align: center + +**Figure1: Morton Code Generation and Quadtree representation** + +2). **Sorting:** For sorting the Morton codes we have used bitonic sorting algorithm. Sorting is used to separate the different Morton codes based on their levels. +3). **Octree Building:** For octree building we have used spatial clustering based method. After Morton coding of x, y, z coordinates each coordinate is represented by single number and each three bits represents one level of octree. After bitonic sorting, we first partition the whole range based on their most significant bits (MSB) starting from range 0 to 7. By this approach, we found the clusters of numbers which have the same MSB which logically represent the spatially neighbor coordinate. After this, we partition each cluster next to their MSB bits. We repeat this until we come to last level or we have least number of leaves left at the end. The highest level of tree which has all the clusters called root node and its partitioned are called nodes. The nodes at the last level are called child nodes and intermediate levels called parent nodes. In this approach, we start from root nodes and then move to leaf nodes that why it is called Top-Down Approach. + + +.. image:: images/OctreeBuild.png + :width: 1338px + :height: 766px + :align: center +**Figure2: Octree Building Steps** + +* **Octree Searching:** +We have implemented point based Approximate nearest search, Radius search and brute force search which search the points in the octree. Next target is to implement this searching on cloud of points in parallel. + +**Filtering Module:** In filtering module lot of algorithms depends on octree based searching which can be optimized by using parallel octree based implementation. We have also optimized some algorithms like median filter; pass through filter, Nan Removal, Convolution, min-max calculation etc. which are not dependent on octree. + +**Tracking Module:** We have optimized particle filtering based tracking inside tracking module. Particle filtering based mostly depends on filtering and searching so we have used optimized filtering and searching. For searching we added PCL search module inside tracking module and added octree method inside it. We have also optimized point based coherence methods like RGBtoHSV conversion and bounding box calculation inside PCL. - Test post