songsenand
/
cgal
mirror of https://github.com/CGAL/cgal
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove some hyphens

This commit is contained in:
Andreas Fabri 2025-05-15 07:28:31 +01:00
parent e811ba2f72
commit e2058c01c6
20 changed files with 34 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Advancing_front_surface_reconstruction/doc/Advancing_front_surface_reconstruction/Advancing_front_surface_reconstruction.txt
View File

@ -49,7 +49,7 @@ We describe next the algorithm and provide examples.
\note A \ref tuto_reconstruction "detailed tutorial on surface reconstruction"
is provided with a guide to choose the most appropriate method along
with pre- and post-processing.
with pre- and postprocessing.
\section AFSR_Definitions Definitions and the Algorithm

4
Advancing_front_surface_reconstruction/include/CGAL/Advancing_front_surface_reconstruction.h
View File

@ -382,7 +382,7 @@ namespace CGAL {
int _facet_number;
//---------------------------------------------------------------------
// For post-processing
// For postprocessing
mutable int _postprocessing_counter;
int _size_before_postprocessing;
@ -2432,7 +2432,7 @@ namespace CGAL {
std::size_t itmp, L_v_size_mem;
L_v_size_mem = L_v.size();
if ((vh_on_border_inserted != 0)&& // to post-process only the borders
if ((vh_on_border_inserted != 0)&& // to postprocess only the borders
(L_v.size() < .1 * _size_before_postprocessing))
{
{

2
Alpha_wrap_3/include/CGAL/Alpha_wrap_3/internal/Alpha_wrap_3.h
View File

@ -348,7 +348,7 @@ public:
#ifdef CGAL_AW3_TIMER
t.stop();
std::cout << "Manifoldness post-processing took: " << t.time() << " s." << std::endl;
std::cout << "Manifoldness postprocessing took: " << t.time() << " s." << std::endl;
t.reset();
t.start();
#endif

2
Boolean_set_operations_2/include/CGAL/Boolean_set_operations_2/Gps_bfs_xor_visitor.h
View File

@ -52,7 +52,7 @@ public:
return (ic % 2) == 1;
}
//! after_scan post-processing after bfs scan.
//! after_scan postprocessing after bfs scan.
/*! The function fixes some of the curves, to be in the same direction as the
half-edges.

2
Documentation/doc/Documentation/Tutorials/Tutorial_reconstruction.txt
View File

@ -255,7 +255,7 @@ through the points.
Each of these methods produce a triangle mesh stored in different
ways. If this output mesh is hampered by defects such as holes or
self-intersections, \cgal provide several algorithms to post-process
self-intersections, \cgal provide several algorithms to postprocess
it (hole filling, remeshing, etc.) in the package \ref PkgPolygonMeshProcessing "Polygon Mesh Processing".
We do not discuss these functions here as there are many

2
Documentation/doc/scripts/test_doxygen_versions.sh
View File

@ -91,7 +91,7 @@ else
bash -$- ./compare_testsuites.sh $PWD/build_doc/doc_output $PWD/doc_ref 1> /dev/null
fi
echo "done."
#add post-processing
#add postprocessing
cd ./build_doc
echo "Adding postprocessing..."
make -j$NB_CORES doc_with_postprocessing &>> ./build_logs

2
Jet_fitting_3/doc/Jet_fitting_3/Jet_fitting_3.txt
View File

@ -280,7 +280,7 @@ computed using rings on the triangulation. Results are twofold:
numerical information on the computation: condition number and the
PCA basis;
<LI>another text file that records raw data (better for a visualization
post-processing).
postprocessing).
</UL>
\cgalFigureRef{figjet3figdavid} and

2
Mesh_3/include/CGAL/Labeled_mesh_domain_3.h
View File

@ -656,7 +656,7 @@ public:
* \cgalParamExtra{The return type of the function depends on whether this parameter
* or `input_features` are provided or not.}
* \cgalParamExtra{If `weights` is provided, it must either be adapted to the detected features,
* or post-processed during feature detection to keep consistency
* or postprocessed during feature detection to keep consistency
* of the output `MeshDomainWithFeatures_3`.
* Available functors implement the necessary modifications.}
* \cgalParamNEnd

4
Poisson_surface_reconstruction_3/doc/Poisson_surface_reconstruction_3/Poisson_surface_reconstruction_3.txt
View File

@ -29,7 +29,7 @@ solving for the implicit function before function evaluation.
\note A \ref tuto_reconstruction "detailed tutorial on surface reconstruction"
is provided with a guide to choose the most appropriate method along
with pre- and post-processing.
with pre- and postprocessing.
\section Poisson_surface_reconstruction_3Common Common Reconstruction Pipeline
@ -45,7 +45,7 @@ and 6) Surface reconstruction.
\cgal provides algorithms for all steps listed above except alignment.
Chapter \ref chappoint_set_processing_3 "Point Set Processing"
describes algorithms to pre-process the point set before
describes algorithms to preprocess the point set before
reconstruction with functions devoted to the simplification, outlier
removal, smoothing, normal estimation and normal orientation.

4
Scale_space_reconstruction_3/doc/Scale_space_reconstruction_3/Scale_space_reconstruction_3.txt
View File

@ -19,7 +19,7 @@ A triangulated surface mesh is generated by first computing the point set at a c
\note A \ref tuto_reconstruction "detailed tutorial on surface reconstruction"
is provided with a guide to choose the most appropriate method along
with pre- and post-processing.
with pre- and postprocessing.
\section ScaleSpaceReconstruction3secMethod Scale-Space
@ -92,7 +92,7 @@ The surface mesh constructed at scale \f$ s \f$ is non-self-intersecting. The in
The surface mesh will not have edges incident to only one triangle or holes, loops of such edges, and the triangles are all oriented away from the point set. If the point set has <em>holes</em>, it is likely that the surface mesh will contain overlapping triangles with opposite orientation touching this hole.
An additional treatment can be applied to force the output surface to be 2-manifold: small flat volumes are found before reconstructing and the surface is forced to only use one side of the volume while keeping consistency with the adjacent singular facets. Only one side of each singular facet is used. In addition, non-manifold edges and vertices are removed as a post-processing. The facets that have been discarded to make the surface 2-manifold are stored and accessible.
An additional treatment can be applied to force the output surface to be 2-manifold: small flat volumes are found before reconstructing and the surface is forced to only use one side of the volume while keeping consistency with the adjacent singular facets. Only one side of each singular facet is used. In addition, non-manifold edges and vertices are removed as a postprocessing. The facets that have been discarded to make the surface 2-manifold are stored and accessible.
If the object is not densely sampled or has disconnected components, the reconstructed surface may have several disconnected components. The surface is either an unordered collection of triangles, or the same collection sorted per \em shell. A shell is a collection of connected triangles that are locally oriented towards the same side of the surface.

2
Set_movable_separability_2/doc/Set_movable_separability_2/Set_movable_separability_2.txt
View File

@ -77,7 +77,7 @@ Chapter_2D_Regularized_Boolean_Set-Operations
"2D Regularized Boolean Set-Operations" for the precise definition
of simple polygons. Secondly, any consecutive three vertices cannot be
collinear. If you suspect that the input polygon may not satisfy the
latter condition, pre-process the polygon to eliminate this
latter condition, preprocess the polygon to eliminate this
ill-condition.
The implementation is based on an algorithm developed by Shamai and

4
Shape_detection/include/CGAL/Polygon_mesh_processing/region_growing.h
View File

@ -126,7 +126,7 @@ private:
\cgalParamExtra{this parameter and `cosine_of_maximum_angle` are exclusive}
\cgalParamNEnd
\cgalParamNBegin{postprocess_regions}
\cgalParamDescription{Apply a post-processing step to the output of the region growing algorithm.}
\cgalParamDescription{Apply a postprocessing step to the output of the region growing algorithm.}
\cgalParamType{`bool`}
\cgalParamDefault{false}
\cgalParamNEnd
@ -212,7 +212,7 @@ region_growing_of_planes_on_faces(const PolygonMesh& mesh,
if (choose_parameter(get_parameter(np, internal_np::postprocess_regions), false))
{
// first try for a post-processing: look at regions made of one face and check if a
// first try for a postprocessing: look at regions made of one face and check if a
// larger region contains its 3 vertices and if so assigned it to it.
typedef typename boost::property_traits<RegionMap>::value_type Id;
for (std::size_t i=0; i<tmp.size(); ++i)

2
Shape_regularization/doc/Shape_regularization/Shape_regularization.txt
View File

@ -253,7 +253,7 @@ only return groups of indices of segments with similar orientations and/or posit
\subsubsection QP_Regularization_Segments_Simplification Simplifying Segments
After regularizing angles and offsets, simplifying segments with similar properties
is a common post-processing task. This \cgal component provides an utility function
is a common postprocessing task. This \cgal component provides an utility function
`Segments::unique_segments()` that takes a set of input segments, groups them with
respect to the collinearity property, and then returns for each group of collinear segments
a segment that best fits this group (see the figure below).

2
Surface_mesh_parameterization/include/CGAL/Surface_mesh_parameterization/ARAP_parameterizer_3.h
View File

@ -128,7 +128,7 @@ namespace Surface_mesh_parameterization {
/// When \f$\lambda\f$ is non-null, the border does not need to be parameterized and
/// a random vertex is pinned.
///
/// If flips are present in the initial parameterization, a post-processing step
/// If flips are present in the initial parameterization, a postprocessing step
/// is applied using `CGAL::Surface_mesh_parameterization::MVC_post_processor_3<TriangleMesh_, SolverTraits_>`
/// to attempt to obtain a valid final embedding.
///

14
Surface_mesh_segmentation/doc/Surface_mesh_segmentation/Surface_Mesh_Segmentation.txt
View File

@ -51,9 +51,9 @@ The raw SDF values are computed through function `sdf_values()`, setting `postpr
or rays that form an obtuse angle with the inward-normal of the first intersected facet are ignored.
Only facets having no ray get no raw SDF values
\subsubsection Surface_mesh_segmentationPostprocessing Post-processing of Raw SDF Values
\subsubsection Surface_mesh_segmentationPostprocessing Postprocessing of Raw SDF Values
After having calculated the raw SDF value for each facet, the SDF values used in the segmentation algorithm are
the result of several post-processing steps:
the result of several postprocessing steps:
- Facets with no raw SDF values are assigned the average raw SDF value of their edge-adjacent neighbors. If there is still a facet having no SDF value,
the minimum amongst all the SDF values is assigned to it (this is a deviation from the description of the algorithm in \cgalCite{Shapira2008Consistent}).
@ -70,7 +70,7 @@ The main reason for not assigning 0 to facets with no SDF values is that it can
Large range parameters make smoothing closer to Gaussian smoothing and may also lead to over-smoothed SDF values.
- SDF values are linearly normalized between [0,1].
These post-processing steps can be applied to raw SDF values (or an alternative set of similar scalar values associated with facets) using the function `sdf_values_postprocessing()`.
These postprocessing steps can be applied to raw SDF values (or an alternative set of similar scalar values associated with facets) using the function `sdf_values_postprocessing()`.
\subsection Surface_mesh_segmentationSoftClustering Soft Clustering
@ -154,11 +154,11 @@ Clusters and segments. The input number of clusters is set to 5. <b>(a)</b> Resu
\subsection Surface_mesh_segmentationAPI Summary
Four functions are provided:
- `sdf_values()` : computes the SDF value of each facet of an input mesh in either raw or post-processed form.
- `sdf_values()` : computes the SDF value of each facet of an input mesh in either raw or postprocessed form.
SDF values are associated to facets using a property map (see \ref Chapter_CGAL_and_Boost_Property_Maps
"CGAL and Boost Property Maps").
- `sdf_values_postprocessing()` : post-processes raw SDF values. The post-processing is decoupled from
the function `sdf_values()` to allow the use of alternative methods to compute SDF values or additional post-processing step.
- `sdf_values_postprocessing()` : postprocesses raw SDF values. The postprocessing is decoupled from
the function `sdf_values()` to allow the use of alternative methods to compute SDF values or additional postprocessing step.
- `segmentation_from_sdf_values()` : computes the mesh segmentation from the SDF values of the facets of an input mesh.
The input SDF values can be any set of scalar values associated to each facet as long as they have been normalized between 0 and 1.
This function allows using the same SDF values with different parameters for the segmentation stage.
@ -188,7 +188,7 @@ This operation is reliable when the `AABBTraits` model provided has exact predic
\cgalExample{Surface_mesh_segmentation/segmentation_from_sdf_values_example.cpp}
\subsubsection Example_3 Computation of SDF Values and Segmentation
The function `segmentation_via_sdf_values()` combines the computation of sdf values, the post-processing and the segmentation.
The function `segmentation_via_sdf_values()` combines the computation of sdf values, the postprocessing and the segmentation.
Note that when computing several segmentations of a mesh with different parameters (i.e. number of levels, and smoothing lambda),
it is advised to first compute the SDF values using `sdf_values()` and use them in calls of the function `segmentation_from_sdf_values()`.

4
Surface_mesh_segmentation/include/CGAL/Surface_mesh_segmentation/internal/Surface_mesh_segmentation.h
View File

@ -45,7 +45,7 @@ namespace CGAL
namespace internal
{
// Post-process functions for sdf values
// postprocess functions for sdf values
template<class Polyhedron>
class Postprocess_sdf_values
{
@ -186,7 +186,7 @@ public:
* - Expectation_maximization for soft clustering
* - An implementation of alpha-expansion graph cut for hard clustering
*
* Other than being a connector, it is also responsible for pre-process and postprocess on intermediate data, which are:
* Other than being a connector, it is also responsible for preprocess and postprocess on intermediate data, which are:
* - log-normalizing probabilities received from soft clustering
* - log-normalizing and calculating dihedral-angle based weights for edges
* - smoothing and log-normalizing sdf values received from sdf calculation (Filters.h)

8
Surface_mesh_segmentation/include/CGAL/mesh_segmentation.h
View File

@ -63,7 +63,7 @@ sdf_values( const TriangleMesh& triangle_mesh,
* @brief Function computing the Shape Diameter Function over a surface mesh.
*
* This function implements the Shape Diameter Function (SDF) as described in \cgalCite{Shapira2008Consistent}.
* It is possible to compute raw SDF values (without post-processing). In such a case,
* It is possible to compute raw SDF values (without postprocessing). In such a case,
* -1 is used to indicate when no SDF value could be computed for a facet.
*
* @pre `is_triangle_mesh(triangle_mesh)`
@ -108,12 +108,12 @@ sdf_values( const TriangleMesh& triangle_mesh,
/*!
* \ingroup PkgSurfaceMeshSegmentationRef
* @brief Function post-processing raw SDF values computed per facet.
* @brief Function postprocessing raw SDF values computed per facet.
*
* Post-processing steps applied :
* Postprocessing steps applied :
* - Facets with -1 SDF values are assigned the average SDF value of their edge-adjacent neighbors.
* If there is still a facet having -1 SDF value, the minimum valid SDF value assigned to it. Note that this step is not inherited from the paper.
* The main reason for not assigning 0 to facets with no SDF values (i.e. -1) is that it can obstruct log-normalization process which takes place at the beginning of `CGAL::segmentation_from_sdf_values()`.
* The main reason for not assigning 0 to facets with no SDF values (i.e., -1) is that it can obstruct log-normalization process which takes place at the beginning of `CGAL::segmentation_from_sdf_values()`.
* - SDF values are smoothed with bilateral filtering.
* - SDF values are linearly normalized between [0,1].
*

2
Tetrahedral_remeshing/doc/Tetrahedral_remeshing/Tetrahedral_remeshing.txt
View File

@ -163,7 +163,7 @@ stored as complex edges in a `Mesh_complex_3_in_triangulation_3`
\subsection ssecEx4 Tetrahedral Remeshing After Mesh Generation
The tetrahedral remeshing algorithm is designed as a post-processing for
The tetrahedral remeshing algorithm is designed as a postprocessing for
mesh generation algorithms. The API allows to generate a tetrahedral mesh
with the \cgal \ref PkgMesh3 package, and
further improve it with the tetrahedral remeshing algorithm.

2
Visibility_2/doc/Visibility_2/CGAL/Rotational_sweep_visibility_2.h
View File

@ -63,7 +63,7 @@ public:
/*!
Attaches the given arrangement to the visibility object.
This operation takes \cgalBigO{1} as the class does no pre-processing.
This operation takes \cgalBigO{1} as the class does no preprocessing.
In case the object is already attached to another arrangement,
the visibility object gets detached before being attached to `arr`.

2
Visibility_2/doc/Visibility_2/CGAL/Simple_polygon_visibility_2.h
View File

@ -67,7 +67,7 @@ public:
/*!
Attaches the given arrangement to the visibility object.
This operation takes \cgalBigO{1} as the class does no pre-processing.
This operation takes \cgalBigO{1} as the class does no preprocessing.
In case the object is already attached to another arrangement,
the visibility object gets detached before being attached to `arr`.