forked from FreeCAD/FreeCAD
-
Notifications
You must be signed in to change notification settings - Fork 0
/
SketchAnalysis.h
153 lines (131 loc) · 8.46 KB
/
SketchAnalysis.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
/***************************************************************************
* Copyright (c) 2018 Abdullah Tahiri <abdullah.tahiri.yo@gmail.com> *
* Copyright (c) 2013 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* This file is part of the FreeCAD CAx development system. *
* *
* This library is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Library General Public *
* License as published by the Free Software Foundation; either *
* version 2 of the License, or (at your option) any later version. *
* *
* This library is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Library General Public License for more details. *
* *
* You should have received a copy of the GNU Library General Public *
* License along with this library; see the file COPYING.LIB. If not, *
* write to the Free Software Foundation, Inc., 59 Temple Place, *
* Suite 330, Boston, MA 02111-1307, USA *
* *
***************************************************************************/
#ifndef SKETCHER_SKETCHANALYSIS_H
#define SKETCHER_SKETCHANALYSIS_H
#include <vector>
#include <memory>
#include <Base/Vector3D.h>
#include "Analyse.h"
#include "SketchObject.h"
namespace Sketcher {
class SketchObject;
class SketcherExport SketchAnalysis
{
public:
/// Creates an instance of the SketchAnalysis object, taking as parameter a pointer to an SketchObject.
///
/// There is a first type of routines, simple routines, which work in the following order:
/// Detect - (Analyse) - [Get] - [Set] - Make
///
/// The Detect step just identifies possible missing constraints.
///
/// The Analyse, which is not available for all the routines, operates in detected constraints of the same routine, to
/// look for alternatives. For example, a general pointonpoint detection leads to a search for coincident constraints, which
/// can be later run via Analyse if it is intended to convert endpoint coincidence to endpoint perpendicular and tangent constraints.
///
/// The Get retrieves the result of the analysis as a vector of ConstraintIds, indicating the suggested constraints. This step is intended
/// for enabling the user to check the result of the analysis, rather than applying it. If only applying is intended, this step is not necessary
/// as the Make will operate on the result of the Detect - Analyse directly.
///
/// The Set changes the detected result. It modifies the SketchAnalysis object. It only modifies the SketchObject as far as the SketchAnalysis is changed.
/// It does not apply any changes to the sketch. It is intended so as to enable the user to change the result that will be applied.
///
/// Neither the Detect, nor the Analyse, nor the Get steps modify the Sketch geometry.
///
/// Make applies the constraints stored internally in the SketchAnalysis object.
///
/// A second type of routines, complex routines, are thought for running fully automatic and they Detect, Analyse and Make.
/// They may also apply a variaty of types of Constraints.
///
/// A third type of routines do not relate to autoconstraining at all, and include validation methods for sketches.
SketchAnalysis(Sketcher::SketchObject * Obj);
~SketchAnalysis();
// Simple routines (see constructor)
/// Point on Point constraint simple routine Detect step (see constructor)
/// Detect detects only coincident constraints, Analyse converts coincident to endpoint perpendicular/tangent where appropriate
int detectMissingPointOnPointConstraints(double precision = Precision::Confusion() * 1000, bool includeconstruction = true);
/// Point on Point constraint simple routine Analyse step (see constructor)
void analyseMissingPointOnPointCoincident(double angleprecision = M_PI/8);
/// Point on Point constraint simple routine Get step (see constructor)
std::vector<ConstraintIds> &getMissingPointOnPointConstraints(void) {return vertexConstraints;}
/// Vertical/Horizontal constraints simple routine Set step (see constructor)
void setMissingPointOnPointConstraints(std::vector<ConstraintIds>& cl) {vertexConstraints = cl;}
/// Point on Point constraint simple routine Make step (see constructor)
/// if onebyone, then the sketch is solved after each individual constraint addition and any redundancy removed.
void makeMissingPointOnPointCoincident(bool onebyone = false);
/// Vertical/Horizontal constraints simple routine Detect step (see constructor)
int detectMissingVerticalHorizontalConstraints(double angleprecision = M_PI/8);
/// Vertical/Horizontal constraints simple routine Get step (see constructor)
std::vector<ConstraintIds> &getMissingVerticalHorizontalConstraints(void) {return verthorizConstraints;}
/// Vertical/Horizontal constraints simple routine Set step (see constructor)
void setMissingVerticalHorizontalConstraints(std::vector<ConstraintIds>& cl) {verthorizConstraints = cl;}
/// Vertical/Horizontal constraints simple routine Make step (see constructor)
void makeMissingVerticalHorizontal(bool onebyone = false);
/// Equality constraints simple routine Detect step (see constructor)
int detectMissingEqualityConstraints(double precision);
/// Equality constraints simple routine Get step for line segments (see constructor)
std::vector<ConstraintIds> &getMissingLineEqualityConstraints(void) {return lineequalityConstraints;}
/// Equality constraints simple routine Get step for radii (see constructor)
std::vector<ConstraintIds> &getMissingRadiusConstraints(void) {return radiusequalityConstraints;}
/// Equality constraints simple routine Set step for line segments (see constructor)
void setMissingLineEqualityConstraints(std::vector<ConstraintIds>& cl) {lineequalityConstraints = cl;}
/// Equality constraints simple routine Set step for radii (see constructor)
void setMissingRadiusConstraints(std::vector<ConstraintIds>& cl) {radiusequalityConstraints = cl;}
/// Equality constraints simple routine Make step (see constructor)
void makeMissingEquality(bool onebyone = true);
/// Detect degenerated geometries
int detectDegeneratedGeometries(double tolerance);
/// Remove degenerated geometries
int removeDegeneratedGeometries(double tolerance);
// Complex routines (see constructor)
/// Fully automated multi-constraint autoconstraining
///
/// It DELETES all the constraints currently present in the Sketcher. The reason is that it makes assumptions to avoid redundancies.
///
/// It applies coincidents - vertical/horizontal constraints and equality constraints.
int autoconstraint(double precision = Precision::Confusion() * 1000, double angleprecision = M_PI/8, bool includeconstruction = true);
// helper functions, which may be used by more complex methods, and/or called directly by user space (python) methods
/// solves the sketch and retrieves the error status, and the degrees of freedom.
/// It enables to solve updating the geometry (so moving the geometry to match the constraints) or preserving the geometry.
void solvesketch(int &status, int &dofs, bool updategeo);
// third type of routines
std::vector<Base::Vector3d> getOpenVertices(void) const;
protected:
Sketcher::SketchObject* sketch;
struct VertexIds;
struct Vertex_Less;
struct VertexID_Less;
struct Vertex_EqualTo;
struct EdgeIds;
struct Edge_Less;
struct Edge_EqualTo;
std::vector<ConstraintIds> vertexConstraints;
std::vector<ConstraintIds> verthorizConstraints;
std::vector<ConstraintIds> lineequalityConstraints;
std::vector<ConstraintIds> radiusequalityConstraints;
protected:
bool checkHorizontal(Base::Vector3d dir, double angleprecision);
bool checkVertical(Base::Vector3d dir, double angleprecision);
};
} //namespace Sketcher
#endif // SKETCHER_SKETCHANALYSIS_H