Gpu module spelling fixes

Author: jmackay2

gpu/features/include/pcl/gpu/features/features.hpp

@@ -204,7 +204,7 @@ namespace pcl
 
 
         //////////////////////////////////////////////////////////////////////////////////////////////  
-        ///** \brief @b Class for Viewpoint Feature Histogramm estimation.  */
+        ///** \brief @b Class for Viewpoint Feature Histogram estimation.  */
 
         class PCL_EXPORTS VFHEstimation : public FeatureFromNormals
         {

gpu/features/src/normal_3d.cu

@@ -93,7 +93,7 @@ namespace pcl
                 const int *ibeg = indices.ptr(idx);
                 const int *iend = ibeg + size;
 
-                //copmpute centroid
+                //compute centroid
                 float3 c = make_float3(0.f, 0.f, 0.f);
                 for(const int *t = ibeg + lane; t < iend; t += Warp::STRIDE)                
                     c += fetch(*t);
@@ -153,7 +153,7 @@ namespace pcl
                     float3 evals;
 
                     eigen33.compute(tmp, vec_tmp, evecs, evals);
-                    //evecs[0] - eigenvector with the lowerst eigenvalue
+                    //evecs[0] - eigenvector with the lowest eigenvalue
 
                     // Compute the curvature surface change
                     float eig_sum = evals.x + evals.y + evals.z;
@@ -180,7 +180,7 @@ namespace pcl
 
         };
 
-        __global__ void EstimateNormaslKernel(const NormalsEstimator est) { est(); }
+        __global__ void EstimateNormalsKernel(const NormalsEstimator est) { est(); }
 
 
         struct FlipNormal
@@ -242,11 +242,11 @@ void pcl::device::computeNormals(const PointCloud& cloud, const NeighborIndices&
     est.points = cloud;
     est.normals = normals;
 
-    //printFuncAttrib(EstimateNormaslKernel);
+    //printFuncAttrib(EstimateNormalsKernel);
 
     int block = NormalsEstimator::CTA_SIZE;
     int grid = divUp((int)normals.size(), NormalsEstimator::WAPRS);
-    EstimateNormaslKernel<<<grid, block>>>(est);
+    EstimateNormalsKernel<<<grid, block>>>(est);
 
     cudaSafeCall( cudaGetLastError() );        
     cudaSafeCall(cudaDeviceSynchronize());

gpu/octree/include/pcl/gpu/octree/octree.hpp

@@ -62,7 +62,7 @@ namespace pcl
             /** \brief Default constructor.*/             
             Octree();
 
-            /** \brief Denstructor.*/             
+            /** \brief Destructor.*/
             virtual ~Octree();
 
             /** \brief Types */
@@ -98,46 +98,46 @@ namespace pcl
             /** \brief Returns true if tree has been built */
             bool isBuilt() const;
 
-            /** \brief Downloads Octree from GPU to search using CPU function. It use useful for single (not-batch) search */
+            /** \brief Downloads Octree from GPU to search using CPU function. It is useful for single (not-batch) search */
             void internalDownload();
 
-            /** \brief Performs search of all points within given radius on CPU. It call \a internalDownload if necessary
+            /** \brief Performs search of all points within given radius on CPU. It calls \a internalDownload if necessary
               * \param[in] center center of sphere
               * \param[in] radius radious of sphere
-              * \param[out] out indeces of points within give sphere
-              * \param[in] max_nn maximum numver of results returned
+              * \param[out] out indices of points within given sphere
+              * \param[in] max_nn maximum number of results returned
               */
             void radiusSearchHost(const PointType& center, float radius, std::vector<int>& out,
                                   int max_nn = std::numeric_limits<int>::max());
 
-            /** \brief Performs approximate nearest neighbor search on CPU. It call \a internalDownload if necessary
-              * \param[in]  query 3D point for which neighbour is be fetched             
-              * \param[out] out_index neighbour index
-              * \param[out] sqr_dist square distance to the neighbour returned
+            /** \brief Performs approximate nearest neighbor search on CPU. It calls \a internalDownload if necessary
+              * \param[in]  query 3D point for which neighbor is to be fetched
+              * \param[out] out_index neighbor index
+              * \param[out] sqr_dist square distance to the neighbor returned
               */
             void approxNearestSearchHost(const PointType& query, int& out_index, float& sqr_dist);
 
             /** \brief Performs batch radius search on GPU
               * \param[in] centers array of centers 
               * \param[in] radius radius for all queries
-              * \param[in] max_results max number of returned points for each querey
+              * \param[in] max_results max number of returned points for each query
               * \param[out] result results packed to single array
               */
             void radiusSearch(const Queries& centers, float radius, int max_results, NeighborIndices& result) const;
 
             /** \brief Performs batch radius search on GPU
               * \param[in] centers array of centers 
               * \param[in] radiuses array of radiuses
-              * \param[in] max_results max number of returned points for each querey
+              * \param[in] max_results max number of returned points for each query
               * \param[out] result results packed to single array
               */
             void radiusSearch(const Queries& centers, const Radiuses& radiuses, int max_results, NeighborIndices& result) const;
 
             /** \brief Performs batch radius search on GPU
               * \param[in] centers array of centers  
-              * \param[in] indices indices for centers array (only for these points search is performed)
+              * \param[in] indices indices for centers array (only for these points is search performed)
               * \param[in] radius radius for all queries
-              * \param[in] max_results max number of returned points for each querey
+              * \param[in] max_results max number of returned points for each query
               * \param[out] result results packed to single array
               */
             void radiusSearch(const Queries& centers, const Indices& indices, float radius, int max_results, NeighborIndices& result) const;
@@ -175,7 +175,7 @@ namespace pcl
         * \param[in] cloud cloud where to search
         * \param[in] query query point
         * \param[in] radius radius
-        * \param[out] result indeces of points within give sphere
+        * \param[out] result indices of points within give sphere
         * \param[in] buffer buffer for intermediate results. Keep reference to it between calls to eliminate internal allocations
         */             
         PCL_EXPORTS void bruteForceRadiusSearchGPU(const Octree::PointCloud& cloud, const Octree::PointType& query, float radius, DeviceArray<int>& result, DeviceArray<int>& buffer);