| Geant4 Cross Reference |
1 // Created by Laurent Garnier on Fri Jan 30 2 1 // Created by Laurent Garnier on Fri Jan 30 2004.
2 2
3 //#define TOOLS_HATCHER_DEBUG 3 //#define TOOLS_HATCHER_DEBUG
4 4
5 #ifdef TOOLS_HATCHER_DEBUG 5 #ifdef TOOLS_HATCHER_DEBUG
6 #include <cstdio> 6 #include <cstdio>
7 #endif 7 #endif
8 8
9 namespace tools { 9 namespace tools {
10 10
11 ////////////////////////////////////////////// 11 //////////////////////////////////////////////////////////////////////////////
12 // test if the polygone given is correct for h 12 // test if the polygone given is correct for hatching
13 // return FALSE if : 13 // return FALSE if :
14 // - All points are not in the same plan 14 // - All points are not in the same plan
15 // - Number of points <3 15 // - Number of points <3
16 // - Offset point is not in the same plan 16 // - Offset point is not in the same plan
17 // - There is less than three different poi 17 // - There is less than three different points
18 // - The vector from point[0],point[1] is c 18 // - The vector from point[0],point[1] is colinear to point[0],lastPoint
19 ////////////////////////////////////////////// 19 //////////////////////////////////////////////////////////////////////////////
20 20
21 inline bool hatcher::check_polyline(vec3f* lis 21 inline bool hatcher::check_polyline(vec3f* listPoints,unsigned int aNumber){
22 22
23 unsigned int firstOffset =0; 23 unsigned int firstOffset =0;
24 24
25 if ( listPoints[0].equals(listPoints[1],FLT_ 25 if ( listPoints[0].equals(listPoints[1],FLT_EPSILON*FLT_EPSILON*10)) {
26 firstOffset =1; 26 firstOffset =1;
27 } 27 }
28 28
29 if ( listPoints[0].equals(listPoints[aNumber 29 if ( listPoints[0].equals(listPoints[aNumber-1],FLT_EPSILON*FLT_EPSILON*10)) {
30 aNumber --; 30 aNumber --;
31 } 31 }
32 32
33 if ((int)aNumber-firstOffset <3) { 33 if ((int)aNumber-firstOffset <3) {
34 #ifdef TOOLS_HATCHER_DEBUG 34 #ifdef TOOLS_HATCHER_DEBUG
35 ::printf("hatcher::check_polyline : ERROR 35 ::printf("hatcher::check_polyline : ERROR the polygone you give have not enought points!\n\n");
36 #endif 36 #endif
37 return false; 37 return false;
38 } 38 }
39 39
40 40
41 // use to test the polyline and to build the 41 // use to test the polyline and to build the shift vector. A is the first point,
42 // B second and C the last (in fact, the las 42 // B second and C the last (in fact, the last-1)!
43 vec3f AB,AC; 43 vec3f AB,AC;
44 AB.setValue(listPoints[1+firstOffset].getVal 44 AB.setValue(listPoints[1+firstOffset].getValue()[0]-listPoints[0].getValue()[0],
45 listPoints[1+firstOffset].getVal 45 listPoints[1+firstOffset].getValue()[1]-listPoints[0].getValue()[1],
46 listPoints[1+firstOffset].getVal 46 listPoints[1+firstOffset].getValue()[2]-listPoints[0].getValue()[2]); // Vector A->B
47 47
48 48
49 fResolveResult = RESOLVE_COLINEAR; 49 fResolveResult = RESOLVE_COLINEAR;
50 unsigned int test = aNumber; 50 unsigned int test = aNumber;
51 while ((fResolveResult !=0) && (test>2+first 51 while ((fResolveResult !=0) && (test>2+firstOffset)) {
52 test--; 52 test--;
53 AC.setValue(listPoints[test].getValue()[0] 53 AC.setValue(listPoints[test].getValue()[0]-listPoints[0].getValue()[0],
54 listPoints[test].getValue()[1] 54 listPoints[test].getValue()[1]-listPoints[0].getValue()[1],
55 listPoints[test].getValue()[2] 55 listPoints[test].getValue()[2]-listPoints[0].getValue()[2]);
56 56
57 // test if AB != AC*i 57 // test if AB != AC*i
58 resolve_system( AB, 58 resolve_system( AB,
59 AC, 59 AC,
60 vec3f(.0f,.0f,.0f)); 60 vec3f(.0f,.0f,.0f));
61 } 61 }
62 if (fResolveResult == RESOLVE_COLINEAR) { 62 if (fResolveResult == RESOLVE_COLINEAR) {
63 #ifdef TOOLS_HATCHER_DEBUG 63 #ifdef TOOLS_HATCHER_DEBUG
64 ::printf("hatcher::check_polyline : ERROR 64 ::printf("hatcher::check_polyline : ERROR all the point you give are colinear!\n\n");
65 for (unsigned int a =0;a<aNumber;a++) { 65 for (unsigned int a =0;a<aNumber;a++) {
66 printf(" %f %f %f \n",listPoints[a][0],l 66 printf(" %f %f %f \n",listPoints[a][0],listPoints[a][1],listPoints[a][2]); }
67 #endif 67 #endif
68 return false; 68 return false;
69 } 69 }
70 70
71 //////////////////////////////////////////// 71 ///////////////////////////////////////////////////////////////
72 // test if all points of the polyline are on 72 // test if all points of the polyline are on the same plan
73 //////////////////////////////////////////// 73 ///////////////////////////////////////////////////////////////
74 74
75 int falsePoints =0; 75 int falsePoints =0;
76 for (unsigned int a=2+firstOffset;a<aNumber; 76 for (unsigned int a=2+firstOffset;a<aNumber;a++) {
77 resolve_system( AB, 77 resolve_system( AB,
78 AC, 78 AC,
79 vec3f((listPoints[a].ge 79 vec3f((listPoints[a].getValue()[0]-listPoints[0].getValue()[0]),
80 (listPoints[a]. 80 (listPoints[a].getValue()[1]-listPoints[0].getValue()[1]),
81 (listPoints[a]. 81 (listPoints[a].getValue()[2]-listPoints[0].getValue()[2])));
82 if (fResolveResult != 0){ 82 if (fResolveResult != 0){
83 falsePoints++; 83 falsePoints++;
84 } 84 }
85 } 85 }
86 86
87 if (falsePoints !=0) { 87 if (falsePoints !=0) {
88 #ifdef TOOLS_HATCHER_DEBUG 88 #ifdef TOOLS_HATCHER_DEBUG
89 ::printf("hatcher::check_polyline : ERROR 89 ::printf("hatcher::check_polyline : ERROR there is %d points on the polyline witch are not on the same plan!\n\n",falsePoints);
90 #endif 90 #endif
91 return false; 91 return false;
92 } 92 }
93 93
94 // test offset 94 // test offset
95 if (! ((fOffset[0] == FLT_MAX) && (fOffset 95 if (! ((fOffset[0] == FLT_MAX) && (fOffset[1] == FLT_MAX) && (fOffset[2] == FLT_MAX))){
96 resolve_system( AB, 96 resolve_system( AB,
97 AC, 97 AC,
98 fOffset-listPoints[0]); 98 fOffset-listPoints[0]);
99 if (fResolveResult != 0) { 99 if (fResolveResult != 0) {
100 #ifdef TOOLS_HATCHER_DEBUG 100 #ifdef TOOLS_HATCHER_DEBUG
101 ::printf("hatcher::check_polyline : ER 101 ::printf("hatcher::check_polyline : ERROR Offset vector has to be on the same plan!\n\n");
102 #endif 102 #endif
103 return false; 103 return false;
104 } 104 }
105 } 105 }
106 return true; 106 return true;
107 } 107 }
108 108
109 109
110 ////////////////////////////////////////////// 110 //////////////////////////////////////////////////////////////////////////////
111 // draw the hatch into the polyline bounding b 111 // draw the hatch into the polyline bounding box giving in argument
112 // return false if : 112 // return false if :
113 // - All points are not in the same plan 113 // - All points are not in the same plan
114 // - There is a precision error on one or m 114 // - There is a precision error on one or more point
115 // Compute a first sequence of hacth, store re 115 // Compute a first sequence of hacth, store results, compute a second sequence
116 // and match all results to get the correct st 116 // and match all results to get the correct strip points
117 ////////////////////////////////////////////// 117 //////////////////////////////////////////////////////////////////////////////
118 /** Compute stripWidth 118 /** Compute stripWidth
119 * We have to use the conflictNumHatchLineTab, 119 * We have to use the conflictNumHatchLineTab, hatchNumber,listHatchStartPoint tables
120 * also the HatchShiftToMacthPoint tab. 120 * also the HatchShiftToMacthPoint tab.
121 * and the hatch line just compute below 121 * and the hatch line just compute below
122 * We try to made a polyline with all points w 122 * We try to made a polyline with all points witch are on the current hatch and on the next hacth
123 * (distant of stripwidth form current hatch) 123 * (distant of stripwidth form current hatch)
124 * conflictNumHatchLineTab give us something l 124 * conflictNumHatchLineTab give us something like this for current and next hatch
125 * current next 125 * current next current next
126 * 4 4 if we consider th 126 * 4 4 if we consider that ,4 ,4
127 * 0 5 we know the compu 127 * 0 5 we know the compute hatch '0 '5
128 * 1 3 lines, we could l 128 * 1 3 lines, we could link ,1 ,3
129 * 3 2 some of theses li 129 * 3 2 some of theses line numbers '3 '2
130 * 5 so ->> 130 * 5 so ->> ,5
131 * 2 131 * 2 '2
132 * And we have to add some points when Hatch 132 * And we have to add some points when HatchShiftToMacthPoint(point) is between current
133 * and next hatch : We add a point B on inter 133 * and next hatch : We add a point B on intersection of line 0 and 1
134 * current next 134 * current next current next
135 * ,4 ,4 135 * ,4 ,4
136 * '0 B(0,1) '5 136 * '0 B(0,1) '5
137 * ,1 137 * ,1
138 * '3 ,3 138 * '3 ,3
139 * ,5 '2 139 * ,5 '2
140 * '2 140 * '2
141 * 141 *
142 * Now we have to match a way to traverse all 142 * Now we have to match a way to traverse all of theses lines. We have 3 solutions to go from
143 * one line to another : 143 * one line to another :
144 * - go to the next point if there is one betw 144 * - go to the next point if there is one between current and next hatch
145 * - go to the same line but on another hatch 145 * - go to the same line but on another hatch
146 * - go to the next tach point 146 * - go to the next tach point
147 * If there is no solution, we have to close t 147 * If there is no solution, we have to close the polyline strip and go to another point until
148 * all are compute 148 * all are compute
149 */ 149 */
150 150
151 /** first, we have to match 7 different cases 151 /** first, we have to match 7 different cases
152 * 1- all strip hatch are entirely in the poly 152 * 1- all strip hatch are entirely in the polyline
153 * 2- the first strip begin before the polylin 153 * 2- the first strip begin before the polyline and the last end in the polyline
154 * 3- the first strip begin before the polylin 154 * 3- the first strip begin before the polyline and the last ends after
155 * 4- the first strip is entierly in the polyl 155 * 4- the first strip is entierly in the polyline and the last ends after
156 * 5- the strip has only an intersection with 156 * 5- the strip has only an intersection with the second hatch sequence (if it has only an intersection
157 * with the first hatch sequence, it is cas 157 * with the first hatch sequence, it is case 2
158 * 6- the strip has a full intersection 158 * 6- the strip has a full intersection
159 * 7- the strip has no intersection ! 159 * 7- the strip has no intersection !
160 */ 160 */
161 161
162 inline bool hatcher::compute_polyline (vec3f* 162 inline bool hatcher::compute_polyline (vec3f* tabPoints,unsigned int aNumber) {
163 std::vector<vec3f> firstComputePoints; // 163 std::vector<vec3f> firstComputePoints; // copy first Points in
164 std::vector<vec3f> secondComputePoints; // 164 std::vector<vec3f> secondComputePoints; // copy first Points in
165 std::vector<bool> firstComputePointsEnable; 165 std::vector<bool> firstComputePointsEnable; // table of already compute points for first hatch
166 std::vector<bool> secondComputePointsEnable; 166 std::vector<bool> secondComputePointsEnable;// table of already compute points for second hatch
167 std::vector< std::vector<int> > firstCompute 167 std::vector< std::vector<int> > firstComputeConflictNumHatchLineTab; // copy firstComputeConflictNumHatchLineTab in
168 168
169 int firstComputeFirstNumHatch =0; 169 int firstComputeFirstNumHatch =0;
170 unsigned int firstComputeNumberHatchToDraw = 170 unsigned int firstComputeNumberHatchToDraw =0;
171 float firstHatchShiftToMatchFirstPoint = FLT 171 float firstHatchShiftToMatchFirstPoint = FLT_MAX; // use in one case when there is no intersection points: to test we have to fill all the polygone
172 float secondHatchShiftToMatchFirstPoint = FL 172 float secondHatchShiftToMatchFirstPoint = FLT_MAX; // use in one case when there is no intersection points: to test we have to fill all the polygone
173 //call compute for first set of hatch 173 //call compute for first set of hatch
174 if ( !compute_single_polyline (tabPoints,aNu 174 if ( !compute_single_polyline (tabPoints,aNumber))
175 return false; 175 return false;
176 if (fStripWidth ==0) 176 if (fStripWidth ==0)
177 return true; 177 return true;
178 178
179 179
180 //save values 180 //save values
181 for (unsigned int a =0;a<fPoints.size();a++) 181 for (unsigned int a =0;a<fPoints.size();a++){
182 firstComputePoints.push_back(fPoints[a]); 182 firstComputePoints.push_back(fPoints[a]);
183 } 183 }
184 184
185 firstComputeConflictNumHatchLineTab.resize(f 185 firstComputeConflictNumHatchLineTab.resize(fConflictNumHatchLineTab.size());
186 for (unsigned int a=0;a<fConflictNumHatchLin 186 for (unsigned int a=0;a<fConflictNumHatchLineTab.size();a++){
187 firstComputeConflictNumHatchLineTab[a].cle 187 firstComputeConflictNumHatchLineTab[a].clear();
188 for (unsigned int b=0;b<fConflictNumHatchL 188 for (unsigned int b=0;b<fConflictNumHatchLineTab[a].size();b++){
189 firstComputeConflictNumHatchLineTab[a].p 189 firstComputeConflictNumHatchLineTab[a].push_back(fConflictNumHatchLineTab[a][b]);
190 } 190 }
191 } 191 }
192 firstComputeFirstNumHatch = fFirstNumHatch; 192 firstComputeFirstNumHatch = fFirstNumHatch;
193 firstComputeNumberHatchToDraw = fNumberHatch 193 firstComputeNumberHatchToDraw = fNumberHatchToDraw;
194 firstHatchShiftToMatchFirstPoint = fHatchShi 194 firstHatchShiftToMatchFirstPoint = fHatchShiftToMatchPointVec[0];
195 //change the offset vector 195 //change the offset vector
196 fOffset = fOffset+fShiftVec*fStripWidth; 196 fOffset = fOffset+fShiftVec*fStripWidth;
197 197
198 //call compute for second set of hatch 198 //call compute for second set of hatch
199 if ( !compute_single_polyline (tabPoints,aNu 199 if ( !compute_single_polyline (tabPoints,aNumber))
200 return false; 200 return false;
201 201
202 //save values 202 //save values
203 for (unsigned int a =0;a<fPoints.size();a++) 203 for (unsigned int a =0;a<fPoints.size();a++){
204 secondComputePoints.push_back(fPoints[a]); 204 secondComputePoints.push_back(fPoints[a]);
205 } 205 }
206 206
207 secondHatchShiftToMatchFirstPoint = fHatchSh 207 secondHatchShiftToMatchFirstPoint = fHatchShiftToMatchPointVec[0];
208 208
209 209
210 // initialize values 210 // initialize values
211 fPoints.clear(); 211 fPoints.clear();
212 fVertices.clear(); 212 fVertices.clear();
213 213
214 int specialCase=1; 214 int specialCase=1;
215 215
216 //first hatch, case 1 216 //first hatch, case 1
217 if ((firstComputeFirstNumHatch == fFirstNumH 217 if ((firstComputeFirstNumHatch == fFirstNumHatch) && (firstComputeNumberHatchToDraw == fNumberHatchToDraw) && (firstComputeNumberHatchToDraw !=0)) {
218 specialCase =1; 218 specialCase =1;
219 } 219 }
220 //first hatch, case 2 220 //first hatch, case 2
221 else if ((firstComputeFirstNumHatch > fFirst 221 else if ((firstComputeFirstNumHatch > fFirstNumHatch) && (firstComputeNumberHatchToDraw < fNumberHatchToDraw) && (firstComputeNumberHatchToDraw !=0)) {
222 //insert a empty element at the beginning 222 //insert a empty element at the beginning
223 firstComputeConflictNumHatchLineTab.insert 223 firstComputeConflictNumHatchLineTab.insert(firstComputeConflictNumHatchLineTab.begin(), firstComputeConflictNumHatchLineTab.back());
224 firstComputeConflictNumHatchLineTab[0].res 224 firstComputeConflictNumHatchLineTab[0].resize(0);
225 firstComputeFirstNumHatch--; 225 firstComputeFirstNumHatch--;
226 firstComputeNumberHatchToDraw ++; 226 firstComputeNumberHatchToDraw ++;
227 firstComputeConflictNumHatchLineTab[0].cle 227 firstComputeConflictNumHatchLineTab[0].clear();
228 specialCase =2; 228 specialCase =2;
229 229
230 } //second hatch, case 3 230 } //second hatch, case 3
231 else if (((firstComputeFirstNumHatch > fFi 231 else if (((firstComputeFirstNumHatch > fFirstNumHatch) && (firstComputeNumberHatchToDraw == fNumberHatchToDraw)) && (firstComputeNumberHatchToDraw !=0)) {
232 //insert a empty element at the beginning 232 //insert a empty element at the beginning
233 firstComputeConflictNumHatchLineTab.insert 233 firstComputeConflictNumHatchLineTab.insert(firstComputeConflictNumHatchLineTab.begin(),firstComputeConflictNumHatchLineTab.back());
234 firstComputeConflictNumHatchLineTab[0].res 234 firstComputeConflictNumHatchLineTab[0].resize(0);
235 firstComputeConflictNumHatchLineTab[0].cle 235 firstComputeConflictNumHatchLineTab[0].clear();
236 //insert a empty element at the end 236 //insert a empty element at the end
237 fConflictNumHatchLineTab.push_back(firstCo 237 fConflictNumHatchLineTab.push_back(firstComputeConflictNumHatchLineTab.back());
238 fConflictNumHatchLineTab.back().resize(0); 238 fConflictNumHatchLineTab.back().resize(0);
239 fConflictNumHatchLineTab.back().clear(); 239 fConflictNumHatchLineTab.back().clear();
240 firstComputeFirstNumHatch--; 240 firstComputeFirstNumHatch--;
241 firstComputeNumberHatchToDraw ++; 241 firstComputeNumberHatchToDraw ++;
242 specialCase =3; 242 specialCase =3;
243 } //second hatch, case 4 243 } //second hatch, case 4
244 else if (((firstComputeFirstNumHatch == fF 244 else if (((firstComputeFirstNumHatch == fFirstNumHatch) && (firstComputeNumberHatchToDraw > fNumberHatchToDraw)) && (firstComputeNumberHatchToDraw !=0)) {
245 //insert a empty element at the end 245 //insert a empty element at the end
246 fConflictNumHatchLineTab.push_back(firstCo 246 fConflictNumHatchLineTab.push_back(firstComputeConflictNumHatchLineTab.back());
247 fConflictNumHatchLineTab.back().resize(0); 247 fConflictNumHatchLineTab.back().resize(0);
248 fConflictNumHatchLineTab.back().clear(); 248 fConflictNumHatchLineTab.back().clear();
249 specialCase =4; 249 specialCase =4;
250 250
251 } //second hatch, case 5 251 } //second hatch, case 5
252 else if ((firstComputeNumberHatchToDraw == 252 else if ((firstComputeNumberHatchToDraw ==0) && (fNumberHatchToDraw !=0)) {
253 //insert a empty element at the beginning 253 //insert a empty element at the beginning
254 firstComputeConflictNumHatchLineTab.insert 254 firstComputeConflictNumHatchLineTab.insert(firstComputeConflictNumHatchLineTab.begin(),firstComputeConflictNumHatchLineTab.back());
255 firstComputeConflictNumHatchLineTab[0].res 255 firstComputeConflictNumHatchLineTab[0].resize(0);
256 firstComputeConflictNumHatchLineTab[0].cle 256 firstComputeConflictNumHatchLineTab[0].clear();
257 firstComputeNumberHatchToDraw ++; 257 firstComputeNumberHatchToDraw ++;
258 specialCase =5; 258 specialCase =5;
259 259
260 } //second hatch, case 6 260 } //second hatch, case 6
261 else if (floorf(firstHatchShiftToMatchFirstP 261 else if (floorf(firstHatchShiftToMatchFirstPoint) != floorf(secondHatchShiftToMatchFirstPoint)) {
262 specialCase =6; 262 specialCase =6;
263 263
264 //fill all the polygone ! 264 //fill all the polygone !
265 fVertices.push_back(aNumber); 265 fVertices.push_back(aNumber);
266 for (unsigned int a =0;a<aNumber;a++){ 266 for (unsigned int a =0;a<aNumber;a++){
267 fPoints.push_back(tabPoints[a]); 267 fPoints.push_back(tabPoints[a]);
268 } 268 }
269 return true; 269 return true;
270 } 270 }
271 else if (floorf(firstHatchShiftToMatchFirstP 271 else if (floorf(firstHatchShiftToMatchFirstPoint) == floorf(secondHatchShiftToMatchFirstPoint)) {
272 specialCase =7; 272 specialCase =7;
273 return true; 273 return true;
274 } else { 274 } else {
275 #ifdef TOOLS_HATCHER_DEBUG 275 #ifdef TOOLS_HATCHER_DEBUG
276 ::printf("hatcher::drawStripPolyline : WAR 276 ::printf("hatcher::drawStripPolyline : WARNING there is a case witch was not done in the algotithm...possibly some drawing problems.\n\n");
277 #endif 277 #endif
278 278
279 } 279 }
280 280
281 281
282 bool result; 282 bool result;
283 bool find; // temp variable 283 bool find; // temp variable
284 int firstHatchComputePoint = 0; //first poin 284 int firstHatchComputePoint = 0; //first point number
285 int secondHatchComputePoint = 0; //first poi 285 int secondHatchComputePoint = 0; //first point number
286 unsigned int lineNumber; 286 unsigned int lineNumber;
287 unsigned int firstPointTabInd =0; 287 unsigned int firstPointTabInd =0;
288 unsigned int secondPointTabInd=0; 288 unsigned int secondPointTabInd=0;
289 unsigned int currentHatch; // 0 is first, 1 289 unsigned int currentHatch; // 0 is first, 1 is second, 2 is one or other !!
290 unsigned int solution; //default for beginni 290 unsigned int solution; //default for beginning
291 unsigned int indTmp; 291 unsigned int indTmp;
292 unsigned int oldSolution; 292 unsigned int oldSolution;
293 for (unsigned int indHatch =0;indHatch<first 293 for (unsigned int indHatch =0;indHatch<firstComputeNumberHatchToDraw;indHatch++) {
294 294
295 295
296 currentHatch =0; // 0 is first, 1 is secon 296 currentHatch =0; // 0 is first, 1 is second
297 solution =99; //default for beginning 297 solution =99; //default for beginning
298 indTmp = 0; 298 indTmp = 0;
299 lineNumber = 0; 299 lineNumber = 0;
300 secondComputePointsEnable.clear(); 300 secondComputePointsEnable.clear();
301 firstComputePointsEnable.clear(); 301 firstComputePointsEnable.clear();
302 for (unsigned int a=0;a<firstComputeConfli 302 for (unsigned int a=0;a<firstComputeConflictNumHatchLineTab[indHatch].size();a++){
303 firstComputePointsEnable.push_back(false 303 firstComputePointsEnable.push_back(false);}
304 for (unsigned int a=0;a<fConflictNumHatchL 304 for (unsigned int a=0;a<fConflictNumHatchLineTab[indHatch].size();a++){
305 secondComputePointsEnable.push_back(fals 305 secondComputePointsEnable.push_back(false);}
306 306
307 if ((indHatch == 0) && ((specialCase ==2) 307 if ((indHatch == 0) && ((specialCase ==2) || (specialCase ==3) || (specialCase ==5))) {
308 for (unsigned int a=0;a<firstComputeConf 308 for (unsigned int a=0;a<firstComputeConflictNumHatchLineTab[indHatch].size();a++){
309 firstComputePointsEnable[a] = true; 309 firstComputePointsEnable[a] = true;
310 } 310 }
311 } 311 }
312 if ((indHatch == (firstComputeNumberHatchT 312 if ((indHatch == (firstComputeNumberHatchToDraw-1)) && ((specialCase ==3) || (specialCase ==4))) {
313 for (unsigned int a=0;a<fConflictNumHatc 313 for (unsigned int a=0;a<fConflictNumHatchLineTab[indHatch].size();a++){
314 secondComputePointsEnable[a] = true; 314 secondComputePointsEnable[a] = true;
315 } 315 }
316 } 316 }
317 317
318 result = false; 318 result = false;
319 while (result == false) { 319 while (result == false) {
320 320
321 321
322 //find a uncompute point for this set of 322 //find a uncompute point for this set of hatch
323 result =true; 323 result =true;
324 unsigned int b=0; 324 unsigned int b=0;
325 while ((result == true) && (b<firstCompu 325 while ((result == true) && (b<firstComputeConflictNumHatchLineTab[indHatch].size())) {
326 if (firstComputePointsEnable[b] == fal 326 if (firstComputePointsEnable[b] == false) {
327 result =false; 327 result =false;
328 firstHatchComputePoint = b; 328 firstHatchComputePoint = b;
329 lineNumber = firstComputeConflictNum 329 lineNumber = firstComputeConflictNumHatchLineTab[indHatch][b];
330 fPoints.push_back(firstComputePoints 330 fPoints.push_back(firstComputePoints[b+firstPointTabInd]);
331 fVertices.push_back(1); 331 fVertices.push_back(1);
332 firstComputePointsEnable[b] = true; 332 firstComputePointsEnable[b] = true;
333 currentHatch = 0; 333 currentHatch = 0;
334 } 334 }
335 b++; 335 b++;
336 } 336 }
337 if (result ==true) { 337 if (result ==true) {
338 //find a uncompute point for this set 338 //find a uncompute point for this set of hatch
339 339
340 while ((result == true) && (b<fConflic 340 while ((result == true) && (b<fConflictNumHatchLineTab[indHatch].size())) {
341 if (secondComputePointsEnable[b] == 341 if (secondComputePointsEnable[b] == false) {
342 result =false; 342 result =false;
343 secondHatchComputePoint = b; 343 secondHatchComputePoint = b;
344 lineNumber = fConflictNumHatchLine 344 lineNumber = fConflictNumHatchLineTab[indHatch][b];
345 fPoints.push_back(secondComputePoi 345 fPoints.push_back(secondComputePoints[b+secondPointTabInd]);
346 fVertices.push_back(1); 346 fVertices.push_back(1);
347 secondComputePointsEnable[b] = tru 347 secondComputePointsEnable[b] = true;
348 currentHatch = 1; 348 currentHatch = 1;
349 } 349 }
350 b++; 350 b++;
351 } 351 }
352 } 352 }
353 if (result == true) { 353 if (result == true) {
354 } 354 }
355 solution =99; // to enter in the while 355 solution =99; // to enter in the while
356 while (solution !=0) { 356 while (solution !=0) {
357 oldSolution = solution; 357 oldSolution = solution;
358 solution =0; //default 358 solution =0; //default
359 // get the line number for this poin 359 // get the line number for this point
360 /** Now we have to match a way to tr 360 /** Now we have to match a way to traverse all of theses lines. We have 3 solutions to go from
361 * one line to another : 361 * one line to another :
362 * - go to the next point if there i 362 * - go to the next point if there is one between current and next hatch
363 * - go to the same line but on anot 363 * - go to the same line but on another hatch
364 * - go to the next hatch point 364 * - go to the next hatch point
365 */ 365 */
366 if (currentHatch != 1) { 366 if (currentHatch != 1) {
367 367
368 if (oldSolution != 3) { 368 if (oldSolution != 3) { // could go to first solution
369 int index =0; 369 int index =0;
370 if ((firstHatchComputePoint % 2 370 if ((firstHatchComputePoint % 2 == 0) && (firstComputePointsEnable[firstHatchComputePoint+1] == false)) index =1;
371 else if ((firstHatchComputePoint 371 else if ((firstHatchComputePoint % 2 != 0) && (firstComputePointsEnable[firstHatchComputePoint-1] == false)) index = -1;
372 if (index !=0) { 372 if (index !=0) {
373 solution = 1; 373 solution = 1;
374 oldSolution = 0; 374 oldSolution = 0;
375 firstHatchComputePoint = first 375 firstHatchComputePoint = firstHatchComputePoint+index;
376 fPoints.push_back(firstCompute 376 fPoints.push_back(firstComputePoints[firstHatchComputePoint+firstPointTabInd]);
377 fVertices.back() ++; 377 fVertices.back() ++;
378 firstComputePointsEnable[first 378 firstComputePointsEnable[firstHatchComputePoint] = true;
379 lineNumber = firstComputeConfl 379 lineNumber = firstComputeConflictNumHatchLineTab[indHatch][firstHatchComputePoint];
380 } 380 }
381 } 381 }
382 if (solution == 0) { 382 if (solution == 0) { // could go to second solution
383 indTmp = 0; 383 indTmp = 0;
384 while ((solution == 0) && (indTm 384 while ((solution == 0) && (indTmp < fConflictNumHatchLineTab[indHatch].size())) {
385 if ((fConflictNumHatchLineTab[ 385 if ((fConflictNumHatchLineTab[indHatch][indTmp] == (int)lineNumber) && (secondComputePointsEnable[indTmp] == false)) {
386 solution =2; 386 solution =2;
387 oldSolution = 0; 387 oldSolution = 0;
388 fPoints.push_back(secondComp 388 fPoints.push_back(secondComputePoints[indTmp+secondPointTabInd]);
389 fVertices.back() ++; 389 fVertices.back() ++;
390 secondComputePointsEnable[in 390 secondComputePointsEnable[indTmp] = true;
391 lineNumber = fConflictNumHat 391 lineNumber = fConflictNumHatchLineTab[indHatch][indTmp];
392 secondHatchComputePoint = in 392 secondHatchComputePoint = indTmp;
393 currentHatch =1; 393 currentHatch =1;
394 } 394 }
395 indTmp ++; 395 indTmp ++;
396 } 396 }
397 } 397 }
398 if (solution == 0) { 398 if (solution == 0) { // could go to first solution
399 indTmp = 0; 399 indTmp = 0;
400 while ((solution == 0) && (indTm 400 while ((solution == 0) && (indTmp < aNumber)) {
401 401
402 if ((fHatchShiftToMatchPointVe 402 if ((fHatchShiftToMatchPointVec[indTmp] > ((float)firstComputeFirstNumHatch+(float)indHatch-fStripWidth))
403 && (fHatchShiftToMatchPoin 403 && (fHatchShiftToMatchPointVec[indTmp] < ((float)firstComputeFirstNumHatch+(float)indHatch))
404 && ((indTmp == lineNumber) 404 && ((indTmp == lineNumber) || (indTmp==lineNumber+1) || ((lineNumber == (aNumber-1)) && (indTmp ==0)))) {
405 find = false; 405 find = false;
406 unsigned a =0; 406 unsigned a =0;
407 while ((a<fVertices.back()) 407 while ((a<fVertices.back()) && (find == false)) {
408 if ((tabPoints[indTmp][0] 408 if ((tabPoints[indTmp][0] == fPoints[a][0]) && (tabPoints[indTmp][1] == fPoints[a][1]) && (tabPoints[indTmp][2] == fPoints[a][2])) find = true;
409 a++; 409 a++;
410 } 410 }
411 if (find == false){ 411 if (find == false){
412 solution = 3; 412 solution = 3;
413 oldSolution = 0; 413 oldSolution = 0;
414 currentHatch =2; 414 currentHatch =2;
415 fPoints.push_back(tabPoint 415 fPoints.push_back(tabPoints[indTmp]);
416 fVertices.back() ++; 416 fVertices.back() ++;
417 if (lineNumber == indTmp) 417 if (lineNumber == indTmp) {
418 if (indTmp >0) lineNumb 418 if (indTmp >0) lineNumber = indTmp-1;
419 else lineNumber = aNumbe 419 else lineNumber = aNumber-1;
420 } 420 }
421 else { 421 else {
422 if (indTmp < aNumber-1) 422 if (indTmp < aNumber-1) lineNumber = indTmp;
423 else lineNumber = 0; 423 else lineNumber = 0;
424 } 424 }
425 } 425 }
426 } 426 }
427 indTmp++; 427 indTmp++;
428 } 428 }
429 } 429 }
430 } // end of current hatch 430 } // end of current hatch
431 431
432 //test of second hatch if currentH 432 //test of second hatch if currentHatch is second
433 if ((oldSolution != 0) && (solution 433 if ((oldSolution != 0) && (solution !=2) && (currentHatch !=0)) {
434 434
435 if (oldSolution != 3){ 435 if (oldSolution != 3){ // could go to first solution
436 int index =0; 436 int index =0;
437 if ((secondHatchComputePoint % 2 437 if ((secondHatchComputePoint % 2 == 0) && (secondComputePointsEnable[secondHatchComputePoint+1] == false)) index =1;
438 else if ((secondHatchComputePoin 438 else if ((secondHatchComputePoint % 2 != 0) && (secondComputePointsEnable[secondHatchComputePoint-1] == false)) index = -1;
439 if (index !=0){ 439 if (index !=0){
440 solution = 1; 440 solution = 1;
441 secondHatchComputePoint = seco 441 secondHatchComputePoint = secondHatchComputePoint+index;
442 fPoints.push_back(secondComput 442 fPoints.push_back(secondComputePoints[secondHatchComputePoint+secondPointTabInd]);
443 fVertices.back() ++; 443 fVertices.back() ++;
444 secondComputePointsEnable[seco 444 secondComputePointsEnable[secondHatchComputePoint] = true;
445 lineNumber = fConflictNumHatch 445 lineNumber = fConflictNumHatchLineTab[indHatch][secondHatchComputePoint];
446 } 446 }
447 } 447 }
448 if (solution == 0) { 448 if (solution == 0) { // could go to second solution
449 indTmp = 0; 449 indTmp = 0;
450 while ((solution == 0) && (indTm 450 while ((solution == 0) && (indTmp < firstComputeConflictNumHatchLineTab[indHatch].size())) {
451 if ((firstComputeConflictNumHa 451 if ((firstComputeConflictNumHatchLineTab[indHatch][indTmp] == (int)lineNumber) && (firstComputePointsEnable[indTmp] == false)) {
452 solution =2; 452 solution =2;
453 fPoints.push_back(firstCompu 453 fPoints.push_back(firstComputePoints[indTmp+firstPointTabInd]);
454 fVertices.back() ++; 454 fVertices.back() ++;
455 firstComputePointsEnable[ind 455 firstComputePointsEnable[indTmp] = true;
456 lineNumber = firstComputeCon 456 lineNumber = firstComputeConflictNumHatchLineTab[indHatch][indTmp];
457 firstHatchComputePoint = ind 457 firstHatchComputePoint = indTmp;
458 currentHatch =0; 458 currentHatch =0;
459 } 459 }
460 indTmp ++; 460 indTmp ++;
461 } 461 }
462 } 462 }
463 if (solution == 0) { 463 if (solution == 0) { // could go to first solution
464 indTmp = 0; 464 indTmp = 0;
465 while ((solution == 0) && (indTm 465 while ((solution == 0) && (indTmp < aNumber)) {
466 466
467 if ((fHatchShiftToMatchPointVe 467 if ((fHatchShiftToMatchPointVec[indTmp] > ((float)fFirstNumHatch+(float)indHatch-fStripWidth))
468 && (fHatchShiftToMatchPoin 468 && (fHatchShiftToMatchPointVec[indTmp] < ((float)fFirstNumHatch+(float)indHatch))
469 && ((indTmp == lineNumber) 469 && ((indTmp == lineNumber) || (indTmp==lineNumber+1) || ((lineNumber == (aNumber-1)) && (indTmp ==0)))) {
470 find = false; 470 find = false;
471 unsigned a =0; 471 unsigned a =0;
472 while ((a<fVertices.back()) 472 while ((a<fVertices.back()) && (find == false)) {
473 if ((tabPoints[indTmp][0] 473 if ((tabPoints[indTmp][0] == fPoints[a][0]) && (tabPoints[indTmp][1] == fPoints[a][1]) && (tabPoints[indTmp][2] == fPoints[a][2])) find = true;
474 a++; 474 a++;
475 } 475 }
476 if (find == false){ 476 if (find == false){
477 currentHatch =2; 477 currentHatch =2;
478 solution = 3; 478 solution = 3;
479 fPoints.push_back(tabPoint 479 fPoints.push_back(tabPoints[indTmp]);
480 fVertices.back() ++; 480 fVertices.back() ++;
481 if (lineNumber == indTmp) 481 if (lineNumber == indTmp) {
482 if (indTmp >0) lineNumb 482 if (indTmp >0) lineNumber = indTmp-1;
483 else lineNumber = aNumbe 483 else lineNumber = aNumber-1;
484 } 484 }
485 else { 485 else {
486 if (indTmp < aNumber-1) 486 if (indTmp < aNumber-1) lineNumber = indTmp;
487 else lineNumber = 0; 487 else lineNumber = 0;
488 } 488 }
489 } 489 }
490 } 490 }
491 indTmp++; 491 indTmp++;
492 } 492 }
493 } 493 }
494 } // end of current hatch 494 } // end of current hatch
495 if (solution == 0) { 495 if (solution == 0) {
496 // the end for this polyline 496 // the end for this polyline
497 // close polyline 497 // close polyline
498 fPoints.push_back(fPoints[fPoints. 498 fPoints.push_back(fPoints[fPoints.size()-fVertices.back()]);
499 fVertices.back() ++; 499 fVertices.back() ++;
500 result =true; 500 result =true;
501 } 501 }
502 } // while solution !=0 502 } // while solution !=0
503 // } // if result 503 // } // if result
504 } // while result 504 } // while result
505 for (unsigned int a =0;a<fVertices.size(); 505 for (unsigned int a =0;a<fVertices.size();a++){
506 #ifdef TOOLS_HATCHER_DEBUG 506 #ifdef TOOLS_HATCHER_DEBUG
507 if (fVertices[a] <4) ::printf("hatcher:: 507 if (fVertices[a] <4) ::printf("hatcher::drawStripPolyline : WARNING A strip polyline has been compute with less than 3 points, it could be an error in the algorithm or a special case.\n\n");
508 #endif 508 #endif
509 } 509 }
510 510
511 firstPointTabInd += firstComputeConflictNu 511 firstPointTabInd += firstComputeConflictNumHatchLineTab[indHatch].size();
512 secondPointTabInd += fConflictNumHatchLine 512 secondPointTabInd += fConflictNumHatchLineTab[indHatch].size();
513 } //end for 513 } //end for
514 return true; 514 return true;
515 } 515 }
516 516
517 517
518 518
519 519
520 ////////////////////////////////////////////// 520 //////////////////////////////////////////////////////////////////////////////
521 // draw the hatch into the polyline bounding b 521 // draw the hatch into the polyline bounding box giving in argument
522 // return false if : 522 // return false if :
523 // - All points are not in the same plan 523 // - All points are not in the same plan
524 // - There is a precision error on one or m 524 // - There is a precision error on one or more point
525 ////////////////////////////////////////////// 525 //////////////////////////////////////////////////////////////////////////////
526 526
527 inline bool hatcher::compute_single_polyline ( 527 inline bool hatcher::compute_single_polyline (vec3f* tabPoints,unsigned int aNumber) {
528 std::vector<vec3f> listNormalVec; 528 std::vector<vec3f> listNormalVec;
529 int numberOfPolylinePoints =0; 529 int numberOfPolylinePoints =0;
530 fPoints.resize(0); 530 fPoints.resize(0);
531 fPoints.clear(); 531 fPoints.clear();
532 int precisionError =0; 532 int precisionError =0;
533 unsigned int firstOffset =0; 533 unsigned int firstOffset =0;
534 fFirstNumHatch =0; 534 fFirstNumHatch =0;
535 fNumberHatchToDraw =0; 535 fNumberHatchToDraw =0;
536 fVertices.resize(0); 536 fVertices.resize(0);
537 fVertices.clear(); 537 fVertices.clear();
538 538
539 if ( tabPoints[0].equals(tabPoints[1].getVal 539 if ( tabPoints[0].equals(tabPoints[1].getValue(),FLT_EPSILON*FLT_EPSILON*10)) {
540 firstOffset =1; } 540 firstOffset =1; }
541 541
542 vec3f* listPoints = new vec3f[aNumber+1-firs 542 vec3f* listPoints = new vec3f[aNumber+1-firstOffset];
543 543
544 for (unsigned int i=0;i<aNumber;i++){ 544 for (unsigned int i=0;i<aNumber;i++){
545 if ((i==0) || (listPoints[i-1] !=tabPoints 545 if ((i==0) || (listPoints[i-1] !=tabPoints[i+firstOffset])) {
546 listPoints[numberOfPolylinePoints] = tab 546 listPoints[numberOfPolylinePoints] = tabPoints[i+firstOffset];
547 numberOfPolylinePoints++; 547 numberOfPolylinePoints++;
548 } 548 }
549 } 549 }
550 550
551 // add the first point on last position to c 551 // add the first point on last position to close the line
552 if ( ! listPoints[0].equals(listPoints[numbe 552 if ( ! listPoints[0].equals(listPoints[numberOfPolylinePoints-1].getValue(),FLT_EPSILON*FLT_EPSILON*10)) {
553 listPoints[numberOfPolylinePoints]=listPoi 553 listPoints[numberOfPolylinePoints]=listPoints[0];
554 numberOfPolylinePoints ++; 554 numberOfPolylinePoints ++;
555 } 555 }
556 556
557 // use to test the polyline and to build the 557 // use to test the polyline and to build the shift vector. A is the first point,
558 // B second and C the last (in fact, the las 558 // B second and C the last (in fact, the last-1)!
559 vec3f AB,AC; 559 vec3f AB,AC;
560 AB.setValue(listPoints[1].getValue()[0]-list 560 AB.setValue(listPoints[1].getValue()[0]-listPoints[0].getValue()[0],
561 listPoints[1].getValue()[1]-list 561 listPoints[1].getValue()[1]-listPoints[0].getValue()[1],
562 listPoints[1].getValue()[2]-list 562 listPoints[1].getValue()[2]-listPoints[0].getValue()[2]); // Vector A->B
563 563
564 fResolveResult = RESOLVE_COLINEAR; 564 fResolveResult = RESOLVE_COLINEAR;
565 unsigned int test = numberOfPolylinePoints-1 565 unsigned int test = numberOfPolylinePoints-1;
566 while ((fResolveResult !=0) && (test>1)) { 566 while ((fResolveResult !=0) && (test>1)) {
567 test--; 567 test--;
568 AC.setValue(listPoints[test].getValue()[0] 568 AC.setValue(listPoints[test].getValue()[0]-listPoints[0].getValue()[0],
569 listPoints[test].getValue()[1] 569 listPoints[test].getValue()[1]-listPoints[0].getValue()[1],
570 listPoints[test].getValue()[2] 570 listPoints[test].getValue()[2]-listPoints[0].getValue()[2]);
571 571
572 // test if AB != AC*i 572 // test if AB != AC*i
573 resolve_system( AB, 573 resolve_system( AB,
574 AC, 574 AC,
575 vec3f(.0f,.0f,.0f)); 575 vec3f(.0f,.0f,.0f));
576 } 576 }
577 if (fResolveResult == RESOLVE_COLINEAR) { 577 if (fResolveResult == RESOLVE_COLINEAR) {
578 #ifdef TOOLS_HATCHER_DEBUG 578 #ifdef TOOLS_HATCHER_DEBUG
579 ::printf("hatcher::drawPolyline : ERROR al 579 ::printf("hatcher::drawPolyline : ERROR all the point you give are colinear!\n\n");
580 for (unsigned int a =0;a<aNumber;a++) { 580 for (unsigned int a =0;a<aNumber;a++) {
581 printf(" %f %f %f \n",listPoints[a][0],l 581 printf(" %f %f %f \n",listPoints[a][0],listPoints[a][1],listPoints[a][2]); }
582 #endif 582 #endif
583 delete [] listPoints; 583 delete [] listPoints;
584 return false; 584 return false;
585 } 585 }
586 586
587 //////////////////////////////////////////// 587 ///////////////////////////////////////////////////////////////
588 // creation of the dirVec. It is done with t 588 // creation of the dirVec. It is done with the dirAngle field
589 // The angle is the one between the first li 589 // The angle is the one between the first line (point 1-point0)
590 // and the dirVec, on the plan delimited by 590 // and the dirVec, on the plan delimited by polyline
591 // Given in the direct axis ((point1-point0) 591 // Given in the direct axis ((point1-point0),(lastPoint-point0),normalPlanVec)
592 // Normal plane Vector = AB x AC 592 // Normal plane Vector = AB x AC
593 //////////////////////////////////////////// 593 ///////////////////////////////////////////////////////////////
594 if (fFirstPolyline) { 594 if (fFirstPolyline) {
595 595
596 fFirstPolyline = false; 596 fFirstPolyline = false;
597 597
598 fNormal.setValue(AB[1]*AC[2]-AB[2]*AC[1], 598 fNormal.setValue(AB[1]*AC[2]-AB[2]*AC[1],
599 AB[2]*AC[0]-AB[ 599 AB[2]*AC[0]-AB[0]*AC[2],
600 AB[0]*AC[1]-AB[ 600 AB[0]*AC[1]-AB[1]*AC[0]);
601 601
602 602
603 // ABPerp Vector = normal x AB 603 // ABPerp Vector = normal x AB
604 vec3f ABPerpVector; 604 vec3f ABPerpVector;
605 ABPerpVector.setValue(fNormal[1]*AB[2]-fNo 605 ABPerpVector.setValue(fNormal[1]*AB[2]-fNormal[2]*AB[1],
606 fNormal[2]*AB[0]-fNo 606 fNormal[2]*AB[0]-fNormal[0]*AB[2],
607 fNormal[0]*AB[1]-fNo 607 fNormal[0]*AB[1]-fNormal[1]*AB[0]);
608 608
609 float normAB =(float)std::sqrt(std::pow(AB 609 float normAB =(float)std::sqrt(std::pow(AB[0],2)+
610 std::pow(AB[1],2)+ 610 std::pow(AB[1],2)+
611 std::pow(AB[2],2)); 611 std::pow(AB[2],2));
612 float normABPerpVector =(float)std::sqrt(s 612 float normABPerpVector =(float)std::sqrt(std::pow(ABPerpVector[0],2)+
613 std::pow(ABPerpVector[ 613 std::pow(ABPerpVector[1],2)+
614 std::pow(ABPerpVector[ 614 std::pow(ABPerpVector[2],2));
615 615
616 float j = std::tan(fDirAngle)*normAB/normA 616 float j = std::tan(fDirAngle)*normAB/normABPerpVector;
617 617
618 if (normABPerpVector == 0){ // never done 618 if (normABPerpVector == 0){ // never done (should be test before)
619 #ifdef TOOLS_HATCHER_DEBUG 619 #ifdef TOOLS_HATCHER_DEBUG
620 ::printf("hatcher::drawPolyline : ERROR 620 ::printf("hatcher::drawPolyline : ERROR Impossible to compute the dir vector for hatch. Normal for this plan is null (normal for : point[0],point[1],lastPoint) point[0], point[1], last point are probably aligned\n\n");
621 #endif 621 #endif
622 delete [] listPoints; 622 delete [] listPoints;
623 return false; 623 return false;
624 } 624 }
625 625
626 fDirVec = AB +(float)j*ABPerpVector; 626 fDirVec = AB +(float)j*ABPerpVector;
627 // normalize vector to unit on X or on Y 627 // normalize vector to unit on X or on Y
628 if (fDirVec.getValue()[0] ==0){ 628 if (fDirVec.getValue()[0] ==0){
629 fDirVec[0] = fPrecisionFactor; // to get 629 fDirVec[0] = fPrecisionFactor; // to get rid of somes errors
630 fDirVec = fDirVec/fDirVec.getValue()[1]; 630 fDirVec = fDirVec/fDirVec.getValue()[1]; // normalize on Y because X will be a big value
631 } else { 631 } else {
632 fDirVec = fDirVec/fDirVec.getValue()[0]; 632 fDirVec = fDirVec/fDirVec.getValue()[0];
633 } 633 }
634 634
635 ////////////////////////////////////////// 635 ///////////////////////////////////////////////////////////////
636 // creation of the shiftVec thanks to the 636 // creation of the shiftVec thanks to the shift field
637 ////////////////////////////////////////// 637 ///////////////////////////////////////////////////////////////
638 638
639 vec3f dirShiftVector; 639 vec3f dirShiftVector;
640 dirShiftVector.setValue(fNormal[1]*fDirVec 640 dirShiftVector.setValue(fNormal[1]*fDirVec.getValue()[2]-fNormal[2]*fDirVec.getValue()[1],
641 fNormal[2]*fDirVec 641 fNormal[2]*fDirVec.getValue()[0]-fNormal[0]*fDirVec.getValue()[2],
642 fNormal[0]*fDirVec 642 fNormal[0]*fDirVec.getValue()[1]-fNormal[1]*fDirVec.getValue()[0]);
643 643
644 // normalize vector to match the shift siz 644 // normalize vector to match the shift size
645 float param = 1.0f; 645 float param = 1.0f;
646 param = (float)std::sqrt((std::pow(fShift, 646 param = (float)std::sqrt((std::pow(fShift,2))/(
647 std::p 647 std::pow(dirShiftVector[0],2)+
648 std::p 648 std::pow(dirShiftVector[1],2)+
649 std::p 649 std::pow(dirShiftVector[2],2)));
650 fShiftVec = dirShiftVector*param; 650 fShiftVec = dirShiftVector*param;
651 651
652 // compute offset only if it was not given 652 // compute offset only if it was not given
653 if ((fOffset[0] == FLT_MAX) && (fOffset[1] 653 if ((fOffset[0] == FLT_MAX) && (fOffset[1] == FLT_MAX) && (fOffset[2] == FLT_MAX)){
654 fOffset = listPoints[0]+fShiftVec*fOffse 654 fOffset = listPoints[0]+fShiftVec*fOffsetValue;
655 } 655 }
656 } 656 }
657 657
658 658
659 //////////////////////////////////////////// 659 /////////////////////////////////////////////
660 // START to compute 660 // START to compute
661 // We compute each line one by one to know w 661 // We compute each line one by one to know witch hatch will be draw thrue this line
662 // we try to know the result of 662 // we try to know the result of
663 // (origin_point_of_hatch)+i*(directionVecto 663 // (origin_point_of_hatch)+i*(directionVector)+j*(shiftVector) = each_point_of_polyline
664 // We will be interest only on j factor for 664 // We will be interest only on j factor for the moment. This factor represent the offset
665 // between the Origin point of the hatch and 665 // between the Origin point of the hatch and the compute point of the polyline
666 // We put results in a float table 666 // We put results in a float table
667 // 667 //
668 // We also have to memorize the min and max 668 // We also have to memorize the min and max number of the hatch to be draw
669 // Point 0 1 2 3 4 5 6 ...n 669 // Point 0 1 2 3 4 5 6 ...n 1
670 // hatchShiftToMatchPoint 5 7 2 6 7 8 5 .. 670 // hatchShiftToMatchPoint 5 7 2 6 7 8 5 ...2 5
671 // min = 1 max = 8 -> 8 hatch to draw 671 // min = 1 max = 8 -> 8 hatch to draw
672 //////////////////////////////////////////// 672 ////////////////////////////////////////////
673 673
674 fHatchShiftToMatchPointVec.resize(numberOfPo 674 fHatchShiftToMatchPointVec.resize(numberOfPolylinePoints+1);
675 float minShiftHatch =FLT_MAX; 675 float minShiftHatch =FLT_MAX;
676 float maxShiftHatch =-FLT_MAX; 676 float maxShiftHatch =-FLT_MAX;
677 vec2f res; 677 vec2f res;
678 678
679 for (int a=0;a<numberOfPolylinePoints;a++) { 679 for (int a=0;a<numberOfPolylinePoints;a++) {
680 res = resolve_system(fDirVec.getValue(), 680 res = resolve_system(fDirVec.getValue(),
681 fShiftVec, 681 fShiftVec,
682 listPoints[a]-fOffset) 682 listPoints[a]-fOffset);
683 // test result 683 // test result
684 if (fResolveResult ==0 ) { 684 if (fResolveResult ==0 ) {
685 fHatchShiftToMatchPointVec[a] = res[1 685 fHatchShiftToMatchPointVec[a] = res[1];
686 if (res[1]>maxShiftHatch) { 686 if (res[1]>maxShiftHatch) {
687 maxShiftHatch = res[1]; 687 maxShiftHatch = res[1];
688 } 688 }
689 if (res[1]<minShiftHatch) { 689 if (res[1]<minShiftHatch) {
690 minShiftHatch = res[1]; 690 minShiftHatch = res[1];
691 } 691 }
692 } 692 }
693 else { // never done (should be test befo 693 else { // never done (should be test before)
694 #ifdef TOOLS_HATCHER_DEBUG 694 #ifdef TOOLS_HATCHER_DEBUG
695 ::printf("hatcher::drawPolyline : ERROR 695 ::printf("hatcher::drawPolyline : ERROR one or more of your polyline points are not on the same plan ! Testing point %d/%d error:%d\n\n",a,numberOfPolylinePoints,fResolveResult);
696 #endif 696 #endif
697 delete [] listPoints; 697 delete [] listPoints;
698 return false; 698 return false;
699 } 699 }
700 } 700 }
701 // for the first point to close the polyline 701 // for the first point to close the polyline
702 fHatchShiftToMatchPointVec[numberOfPolylineP 702 fHatchShiftToMatchPointVec[numberOfPolylinePoints] = fHatchShiftToMatchPointVec[0];
703 fFirstNumHatch = (int)(ceilf(minShiftHatch)) 703 fFirstNumHatch = (int)(ceilf(minShiftHatch));
704 fNumberHatchToDraw = (int)(floorf(maxShiftHa 704 fNumberHatchToDraw = (int)(floorf(maxShiftHatch)-fFirstNumHatch+1);
705 if ((int)(floorf(maxShiftHatch)-fFirstNumHat 705 if ((int)(floorf(maxShiftHatch)-fFirstNumHatch+1) <0) fNumberHatchToDraw =0;
706 706
707 int moreNumberHatchToDraw = fNumberHatchToDr 707 int moreNumberHatchToDraw = fNumberHatchToDraw+1;
708 std::vector<vec3f> listHatchStartPoint; 708 std::vector<vec3f> listHatchStartPoint;
709 std::vector<vec3f> listHatchEndPoint; 709 std::vector<vec3f> listHatchEndPoint;
710 std::vector<int> numberOfStartEndPointsVec; 710 std::vector<int> numberOfStartEndPointsVec;
711 711
712 fConflictNumHatchLineTab.resize(moreNumberHa 712 fConflictNumHatchLineTab.resize(moreNumberHatchToDraw);
713 713
714 // initialize tab 714 // initialize tab
715 for (int a=0;a<moreNumberHatchToDraw;a++) 715 for (int a=0;a<moreNumberHatchToDraw;a++) {
716 numberOfStartEndPointsVec.push_back(0); 716 numberOfStartEndPointsVec.push_back(0);
717 listHatchStartPoint.push_back(vec3f(.0f, 717 listHatchStartPoint.push_back(vec3f(.0f,.0f,.0f));
718 listHatchEndPoint.push_back(vec3f(.0f,.0 718 listHatchEndPoint.push_back(vec3f(.0f,.0f,.0f));
719 fConflictNumHatchLineTab[a].clear(); 719 fConflictNumHatchLineTab[a].clear();
720 } 720 }
721 721
722 //////////////////////////////////////////// 722 /////////////////////////////////////////////
723 // Compute the normalize shift vector for al 723 // Compute the normalize shift vector for all lines
724 // the normal Vector for point 3 to 4 will b 724 // the normal Vector for point 3 to 4 will be listNormalvec[2]
725 //////////////////////////////////////////// 725 /////////////////////////////////////////////
726 726
727 for (int a=0;a<numberOfPolylinePoints-1;a++) 727 for (int a=0;a<numberOfPolylinePoints-1;a++) {
728 res = resolve_system(fDirVec.getValue(), 728 res = resolve_system(fDirVec.getValue(),
729 vec3f(listPoints[a].ge 729 vec3f(listPoints[a].getValue()[0]-listPoints[a+1].getValue()[0],
730 listPoints[a]. 730 listPoints[a].getValue()[1]-listPoints[a+1].getValue()[1],
731 listPoints[a]. 731 listPoints[a].getValue()[2]-listPoints[a+1].getValue()[2]),
732 -fShiftVec); 732 -fShiftVec);
733 if (fResolveResult ==0 ) { 733 if (fResolveResult ==0 ) {
734 listNormalVec.push_back(vec3f(res[1]*(li 734 listNormalVec.push_back(vec3f(res[1]*(listPoints[a+1].getValue()[0]-listPoints[a].getValue()[0]),
735 res[1]* 735 res[1]*(listPoints[a+1].getValue()[1]-listPoints[a].getValue()[1]),
736 res[1]* 736 res[1]*(listPoints[a+1].getValue()[2]-listPoints[a].getValue()[2])
737 )); 737 ));
738 } 738 }
739 else if (fResolveResult == RESOLVE_Z_ERRO 739 else if (fResolveResult == RESOLVE_Z_ERROR ) { // never done (should be test before)
740 #ifdef TOOLS_HATCHER_DEBUG 740 #ifdef TOOLS_HATCHER_DEBUG
741 ::printf("hatcher::drawPolyline : ERROR 741 ::printf("hatcher::drawPolyline : ERROR one or more of your polyline points are not on the same plan !\n\n");
742 #endif 742 #endif
743 delete [] listPoints; 743 delete [] listPoints;
744 return false; 744 return false;
745 } 745 }
746 else{ 746 else{
747 listNormalVec.push_back(vec3f(FLT_MAX,FL 747 listNormalVec.push_back(vec3f(FLT_MAX,FLT_MAX,FLT_MAX));
748 // listNormalVec.append(new vec3f(F 748 // listNormalVec.append(new vec3f(FLT_MAX,FLT_MAX,FLT_MAX));
749 } 749 }
750 } 750 }
751 751
752 //////////////////////////////////////////// 752 /////////////////////////////////////////////
753 // Compute the hatchShiftToMatchPointVec tab 753 // Compute the hatchShiftToMatchPointVec table to try to get the start
754 // and end point of each hatch 754 // and end point of each hatch
755 // if there is more than one start/end point 755 // if there is more than one start/end point, we will resolve it later. For the moment,
756 // we put confict points into a table 756 // we put confict points into a table
757 // HatchNumber 1 2 3 4 757 // HatchNumber 1 2 3 4 5 6 7 8 9
758 // listHatchStartPoint 1,0,0 1,1,0 0,0,1 758 // listHatchStartPoint 1,0,0 1,1,0 0,0,1 0,1,0 1,1,0 0,2,0 1,1,4
759 // listHatchEndPoint .............. 759 // listHatchEndPoint ..............
760 // conflictNumHatchLineTab 5 6 7 760 // conflictNumHatchLineTab 5 6 7
761 // line Number is 0 for (point[0]->point[1]) 761 // line Number is 0 for (point[0]->point[1])
762 // We put each line number into the conflict 762 // We put each line number into the conflict table to be sure to get all the lines
763 // in conflict. When we will thest the valu 763 // in conflict. When we will thest the value of the conflicy table, it should
764 // be greater than 2 to have a conflict 764 // be greater than 2 to have a conflict
765 //////////////////////////////////////////// 765 /////////////////////////////////////////////
766 766
767 vec3f newPoint; 767 vec3f newPoint;
768 int minHatch; 768 int minHatch;
769 int maxHatch; 769 int maxHatch;
770 int hatchIndice =0; 770 int hatchIndice =0;
771 771
772 for (int indPolyline=0;indPolyline<numberOfP 772 for (int indPolyline=0;indPolyline<numberOfPolylinePoints-1;indPolyline++) {
773 minHatch = (int)(ceilf(fHatchShiftToMatchP 773 minHatch = (int)(ceilf(fHatchShiftToMatchPointVec[indPolyline]));
774 maxHatch = (int)(floorf(fHatchShiftToMatch 774 maxHatch = (int)(floorf(fHatchShiftToMatchPointVec[indPolyline+1]));
775 775
776 if (fHatchShiftToMatchPointVec[indPolyline 776 if (fHatchShiftToMatchPointVec[indPolyline+1] <fHatchShiftToMatchPointVec[indPolyline]) {
777 minHatch =(int)(ceilf(fHatchShiftToMatch 777 minHatch =(int)(ceilf(fHatchShiftToMatchPointVec[indPolyline+1]));
778 maxHatch = (int)(floorf(fHatchShiftToMat 778 maxHatch = (int)(floorf(fHatchShiftToMatchPointVec[indPolyline]));
779 } 779 }
780 for (int b=minHatch;b<=maxHatch;b++) { // 780 for (int b=minHatch;b<=maxHatch;b++) { // for all number of hatch fund
781 // compute new point 781 // compute new point
782 hatchIndice = b-fFirstNumHatch; 782 hatchIndice = b-fFirstNumHatch;
783 783
784 newPoint.setValue(listPoints[indPolyline 784 newPoint.setValue(listPoints[indPolyline].getValue()[0]+
785 listNormalVec[indPolyl 785 listNormalVec[indPolyline][0]*(b-fHatchShiftToMatchPointVec[indPolyline]),
786 listPoints[indPolyline 786 listPoints[indPolyline].getValue()[1]+
787 listNormalVec[indPolyl 787 listNormalVec[indPolyline][1]*(b-fHatchShiftToMatchPointVec[indPolyline]),
788 listPoints[indPolyline 788 listPoints[indPolyline].getValue()[2]+
789 listNormalVec[indPolyl 789 listNormalVec[indPolyline][2]*(b-fHatchShiftToMatchPointVec[indPolyline]));
790 790
791 if (numberOfStartEndPointsVec[hatchIndic 791 if (numberOfStartEndPointsVec[hatchIndice] == 0) {// it is the first point
792 //compute point and save it 792 //compute point and save it
793 // the start point will be : 793 // the start point will be :
794 // Point_of_the_line + normalVec * 794 // Point_of_the_line + normalVec *
795 //(number_of_hatch_to_compute - number 795 //(number_of_hatch_to_compute - number_of_hatch_corresponding_to_first_point_of_line)
796 // 796 //
797 if ( (listNormalVec[indPolyline][0] != 797 if ( (listNormalVec[indPolyline][0] != FLT_MAX)
798 && (listNormalVec[indPolyline][1] 798 && (listNormalVec[indPolyline][1] != FLT_MAX)
799 && (listNormalVec[indPolyline][2] 799 && (listNormalVec[indPolyline][2] != FLT_MAX)) {
800 listHatchStartPoint[hatchIndice] = v 800 listHatchStartPoint[hatchIndice] = vec3f(newPoint);
801 fConflictNumHatchLineTab[hatchIndic 801 fConflictNumHatchLineTab[hatchIndice].push_back(indPolyline);
802 numberOfStartEndPointsVec[hatchIndi 802 numberOfStartEndPointsVec[hatchIndice]++;
803 } 803 }
804 } else if (numberOfStartEndPointsVec[hat 804 } else if (numberOfStartEndPointsVec[hatchIndice] == 1) { // it is the second point
805 //compute point and save it (same poin 805 //compute point and save it (same point as previous )
806 // the start point will be : 806 // the start point will be :
807 // Point_of_the_line + normalVec * 807 // Point_of_the_line + normalVec *
808 // (number_of_hatch_to_compute - numb 808 // (number_of_hatch_to_compute - number_of_hatch_corresponding_to_first_point_of_line)
809 // store only if newPoint is != start 809 // store only if newPoint is != start
810 if ((listNormalVec[indPolyline][0] != 810 if ((listNormalVec[indPolyline][0] != FLT_MAX)
811 && (listNormalVec[indPolyline][1] 811 && (listNormalVec[indPolyline][1] != FLT_MAX)
812 && (listNormalVec[indPolyline][2] 812 && (listNormalVec[indPolyline][2] != FLT_MAX)) {
813 listHatchEndPoint[hatchIndice] = vec 813 listHatchEndPoint[hatchIndice] = vec3f(newPoint);
814 fConflictNumHatchLineTab[hatchIndice 814 fConflictNumHatchLineTab[hatchIndice].push_back(indPolyline);
815 numberOfStartEndPointsVec[hatchIndic 815 numberOfStartEndPointsVec[hatchIndice]++;
816 } 816 }
817 } else { // there is a conflict, we don' 817 } else { // there is a conflict, we don't compute anything except for conflicts on points
818 // witch are already compute 818 // witch are already compute
819 // case of the hatch will be draw on a 819 // case of the hatch will be draw on a point of the polyline,
820 // so it match 2 lines + another 820 // so it match 2 lines + another
821 fConflictNumHatchLineTab[hatchIndice]. 821 fConflictNumHatchLineTab[hatchIndice].push_back(indPolyline); // put the line number in conflict table
822 } 822 }
823 } 823 }
824 } 824 }
825 825
826 //////////////////////////////////////////// 826 /////////////////////////////////////////////
827 // Compute the numHatchLine tab and draw cor 827 // Compute the numHatchLine tab and draw correct points
828 //////////////////////////////////////////// 828 /////////////////////////////////////////////
829 std::vector<float> listCoefDirHatch(fNumberH 829 std::vector<float> listCoefDirHatch(fNumberHatchToDraw);
830 std::vector<vec3f> listConflictPoints(number 830 std::vector<vec3f> listConflictPoints(numberOfPolylinePoints);
831 831
832 vec3f ABVec,tempVec; 832 vec3f ABVec,tempVec;
833 int valid =false; 833 int valid =false;
834 bool drawEnabled = false; // true : we could 834 bool drawEnabled = false; // true : we could draw second point, false we wait for the first
835 float temp=0; 835 float temp=0;
836 int tempInt =0; 836 int tempInt =0;
837 float nextPointConflictHatchNumber = -FLT_MA 837 float nextPointConflictHatchNumber = -FLT_MAX;
838 float currentPointConflictHatchNumber = -FLT 838 float currentPointConflictHatchNumber = -FLT_MAX;
839 std::vector<unsigned int> orderConflictLineN 839 std::vector<unsigned int> orderConflictLineNumber;
840 840
841 for (unsigned int hatchNumber =0;hatchNumber 841 for (unsigned int hatchNumber =0;hatchNumber<fNumberHatchToDraw;hatchNumber++) {
842 if ( fConflictNumHatchLineTab[hatchNumber] 842 if ( fConflictNumHatchLineTab[hatchNumber].size() <= 2) {
843 if (!listHatchStartPoint[hatchNumber].eq 843 if (!listHatchStartPoint[hatchNumber].equals(listHatchEndPoint[hatchNumber],FLT_EPSILON*FLT_EPSILON*10)) {
844 fPoints.push_back(listHatchStartPoint[ 844 fPoints.push_back(listHatchStartPoint[hatchNumber]);
845 fPoints.push_back(listHatchEndPoint[ha 845 fPoints.push_back(listHatchEndPoint[hatchNumber]);
846 fVertices.push_back(2); 846 fVertices.push_back(2);
847 } 847 }
848 } else { // there is a conflict 848 } else { // there is a conflict
849 // We read the conflict table and comput 849 // We read the conflict table and compute all the conflict lines
850 // conflict is on hatch number hatchNumb 850 // conflict is on hatch number hatchNumber+ firstNumHatch
851 // Compute the equation on the conflict 851 // Compute the equation on the conflict line (called ABVec ):
852 // i*dirVec - j*ABVec = A-(offset + shif 852 // i*dirVec - j*ABVec = A-(offset + shiftVec * numberHatchToDraw)
853 // and store the i parameter 853 // and store the i parameter
854 // then we 854 // then we
855 855
856 listConflictPoints.clear(); 856 listConflictPoints.clear();
857 listCoefDirHatch.clear(); 857 listCoefDirHatch.clear();
858 std::vector <unsigned int> toRemove; 858 std::vector <unsigned int> toRemove;
859 for (unsigned int conflictLineNumber=0;c 859 for (unsigned int conflictLineNumber=0;conflictLineNumber<fConflictNumHatchLineTab[hatchNumber].size();conflictLineNumber++ )
860 { 860 {
861 861
862 ABVec.setValue(listPoints[fConflictN 862 ABVec.setValue(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]+1].getValue()[0]-listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]].getValue()[0],
863 listPoints[fConflictN 863 listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]+1].getValue()[1]-listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]].getValue()[1],
864 listPoints[fConflictN 864 listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]+1].getValue()[2]-listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]].getValue()[2]);
865 865
866 res = resolve_system(fDirVec.getValu 866 res = resolve_system(fDirVec.getValue(),
867 ABVec, 867 ABVec,
868 vec3f(listPoints 868 vec3f(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]].getValue()[0]-fOffset[0]-((float)hatchNumber+(float)fFirstNumHatch)*fShiftVec[0],
869 listPoin 869 listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]].getValue()[1]-fOffset[1]-((float)hatchNumber+(float)fFirstNumHatch)*fShiftVec[1],
870 listPoin 870 listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]].getValue()[2]-fOffset[2]-((float)hatchNumber+(float)fFirstNumHatch)*fShiftVec[2]));
871 871
872 if (fResolveResult ==0 ) { 872 if (fResolveResult ==0 ) {
873 // we store results 873 // we store results
874 listCoefDirHatch.push_back(2); 874 listCoefDirHatch.push_back(2);
875 listCoefDirHatch.pop_back(); 875 listCoefDirHatch.pop_back();
876 listCoefDirHatch.push_back(res[0]) 876 listCoefDirHatch.push_back(res[0]);
877 res[1] = -res[1]; 877 res[1] = -res[1];
878 listConflictPoints.push_back(vec3f 878 listConflictPoints.push_back(vec3f(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictLineNumber]]+ABVec*res[1]));
879 } 879 }
880 else if (fResolveResult != RESOLVE_C 880 else if (fResolveResult != RESOLVE_COLINEAR){
881 #ifdef TOOLS_HATCHER_DEBUG 881 #ifdef TOOLS_HATCHER_DEBUG
882 printf("hatcher : Precision error 882 printf("hatcher : Precision error during compute on hatch number%d\n\n",hatchNumber);
883 #endif 883 #endif
884 precisionError++; 884 precisionError++;
885 } else { 885 } else {
886 toRemove.push_back(conflictLineNum 886 toRemove.push_back(conflictLineNumber);
887 } 887 }
888 } 888 }
889 889
890 if (toRemove.size()) { 890 if (toRemove.size()) {
891 for (unsigned int conflictLineNumber=0 891 for (unsigned int conflictLineNumber=0;conflictLineNumber<fConflictNumHatchLineTab[hatchNumber].size();conflictLineNumber++ ) {
892 } 892 }
893 // remove potential colinear problems 893 // remove potential colinear problems
894 for (unsigned int aa=0;aa<toRemove.siz 894 for (unsigned int aa=0;aa<toRemove.size();aa++) {
895 unsigned int ind = 0; 895 unsigned int ind = 0;
896 for (std::vector<int>::iterator it = 896 for (std::vector<int>::iterator it = fConflictNumHatchLineTab[hatchNumber].begin();it !=fConflictNumHatchLineTab[hatchNumber].end();it++) {
897 if (ind == toRemove[aa]) { 897 if (ind == toRemove[aa]) {
898 fConflictNumHatchLineTab[hatchNu 898 fConflictNumHatchLineTab[hatchNumber].erase(it);
899 break; 899 break;
900 } 900 }
901 ind++; 901 ind++;
902 } 902 }
903 } 903 }
904 for (unsigned int conflictLineNumber=0 904 for (unsigned int conflictLineNumber=0;conflictLineNumber<fConflictNumHatchLineTab[hatchNumber].size();conflictLineNumber++ ) {
905 } 905 }
906 } 906 }
907 if (listCoefDirHatch.size() != 0) { // a 907 if (listCoefDirHatch.size() != 0) { // all points are resolve_system errors (RESOLVE_COLINEAR or RESOLVE_Z_ERROR
908 908
909 // now, we have to sort all coef dir f 909 // now, we have to sort all coef dir from minus to max
910 // and at the same time, reorder the c 910 // and at the same time, reorder the conflict ponts and the conflict line number
911 // this algorithm is not optimum... 911 // this algorithm is not optimum...
912 valid = false; 912 valid = false;
913 while (valid ==false ) 913 while (valid ==false )
914 { 914 {
915 valid = true; 915 valid = true;
916 for (unsigned int sort =0;sort< li 916 for (unsigned int sort =0;sort< listCoefDirHatch.size()-1;sort++)
917 { 917 {
918 if (listCoefDirHatch[sort]>lis 918 if (listCoefDirHatch[sort]>listCoefDirHatch[sort+1]) {
919 919
920 temp = listCoefDirHatch[sort 920 temp = listCoefDirHatch[sort];
921 listCoefDirHatch[sort] = lis 921 listCoefDirHatch[sort] = listCoefDirHatch[sort+1];
922 listCoefDirHatch[sort+1] =te 922 listCoefDirHatch[sort+1] =temp;
923 tempVec = listConflictPoints 923 tempVec = listConflictPoints[sort];
924 listConflictPoints[sort] = l 924 listConflictPoints[sort] = listConflictPoints[sort+1];
925 listConflictPoints[sort+1] = 925 listConflictPoints[sort+1] = tempVec;
926 tempInt = fConflictNumHatchL 926 tempInt = fConflictNumHatchLineTab[hatchNumber][sort];
927 fConflictNumHatchLineTab[hat 927 fConflictNumHatchLineTab[hatchNumber][sort] = fConflictNumHatchLineTab[hatchNumber][sort+1];
928 fConflictNumHatchLineTab[hat 928 fConflictNumHatchLineTab[hatchNumber][sort+1] = tempInt;
929 valid= false; 929 valid= false;
930 } 930 }
931 } 931 }
932 } 932 }
933 933
934 // once dir coef have been sort, we co 934 // once dir coef have been sort, we could draw lines !!
935 //witch line had made a conflict ??? c 935 //witch line had made a conflict ??? conflictNumHatchLineTab[a]
936 unsigned int conflictNumber =0; 936 unsigned int conflictNumber =0;
937 orderConflictLineNumber.clear(); 937 orderConflictLineNumber.clear();
938 938
939 drawEnabled = false; 939 drawEnabled = false;
940 while (conflictNumber < fConflictNumHa 940 while (conflictNumber < fConflictNumHatchLineTab[hatchNumber].size()) { // while
941 if (conflictNumber+1 == fConflictNum 941 if (conflictNumber+1 == fConflictNumHatchLineTab[hatchNumber].size()) {
942 if(drawEnabled) { 942 if(drawEnabled) {
943 drawEnabled = false; 943 drawEnabled = false;
944 fPoints.push_back(listConflictPo 944 fPoints.push_back(listConflictPoints[conflictNumber].getValue());
945 orderConflictLineNumber.push_bac 945 orderConflictLineNumber.push_back(fConflictNumHatchLineTab[hatchNumber][conflictNumber]);
946 } 946 }
947 } 947 }
948 else { 948 else {
949 // if the conflict point == next c 949 // if the conflict point == next conflict point : that is a end/begin line conflict
950 // else, this is not a big problem 950 // else, this is not a big problem, we just have to invert the drawEnabled
951 // (if we were drawing, we have to 951 // (if we were drawing, we have to finish a line, else, we have to begin a line
952 if ( !(listConflictPoints[conflict 952 if ( !(listConflictPoints[conflictNumber].equals(listConflictPoints[conflictNumber+1],FLT_EPSILON*FLT_EPSILON*10))) {
953 // special case of nextPointline 953 // special case of nextPointline=nextConflict point : hatch//line
954 unsigned int follow=conflictNumb 954 unsigned int follow=conflictNumber+1;
955 bool overContour = false; 955 bool overContour = false;
956 while ((follow <fConflictNumHatc 956 while ((follow <fConflictNumHatchLineTab[hatchNumber].size()) &&
957 (listConflictPoints[confl 957 (listConflictPoints[conflictNumber].equals(listConflictPoints[follow],FLT_EPSILON*FLT_EPSILON*10))) {
958 follow++; 958 follow++;
959 } 959 }
960 //test if next point is on the c 960 //test if next point is on the contour
961 if(follow < fConflictNumHatchLin 961 if(follow < fConflictNumHatchLineTab[hatchNumber].size()) {
962 if ((listConflictPoints[follow 962 if ((listConflictPoints[follow].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][follow]].getValue(),FLT_EPSILON*FLT_EPSILON*10))) {
963 if ((fConflictNumHatchLineTa 963 if ((fConflictNumHatchLineTab[hatchNumber][follow] != 0) &&
964 (fConflictNumHatchLineTa 964 (fConflictNumHatchLineTab[hatchNumber][follow] != numberOfPolylinePoints-1)) {
965 if ((listConflictPoints[co 965 if ((listConflictPoints[conflictNumber].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][follow]-1].getValue(),FLT_EPSILON*FLT_EPSILON*10)) ||
966 (listConflictPoints[co 966 (listConflictPoints[conflictNumber].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][follow]+1].getValue(),FLT_EPSILON*FLT_EPSILON*10))) {
967 overContour = true; 967 overContour = true;
968 } 968 }
969 } 969 }
970 } 970 }
971 } 971 }
972 int previous=conflictNumber-1; 972 int previous=conflictNumber-1;
973 while ((previous >=0) && 973 while ((previous >=0) &&
974 (listConflictPoints[confl 974 (listConflictPoints[conflictNumber].equals(listConflictPoints[previous],FLT_EPSILON*FLT_EPSILON*10))) {
975 previous--; 975 previous--;
976 } 976 }
977 //test if next point is on the c 977 //test if next point is on the contour
978 if(previous >= 0) { 978 if(previous >= 0) {
979 if ((listConflictPoints[confli 979 if ((listConflictPoints[conflictNumber].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictNumber]].getValue(),FLT_EPSILON*FLT_EPSILON*10))) {
980 if ((listConflictPoints[prev 980 if ((listConflictPoints[previous].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictNumber]-1].getValue(),FLT_EPSILON*FLT_EPSILON*10)) ||
981 (listConflictPoints[prev 981 (listConflictPoints[previous].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictNumber]+1].getValue(),FLT_EPSILON*FLT_EPSILON*10))) {
982 overContour = true; 982 overContour = true;
983 } 983 }
984 } 984 }
985 } 985 }
986 if (!overContour) { // we are no 986 if (!overContour) { // we are not on a contour, we can draw
987 fPoints.push_back(listConflict 987 fPoints.push_back(listConflictPoints[conflictNumber].getValue());
988 orderConflictLineNumber.push_b 988 orderConflictLineNumber.push_back(fConflictNumHatchLineTab[hatchNumber][conflictNumber]);
989 drawEnabled = drawEnabled?fals 989 drawEnabled = drawEnabled?false:true;
990 if (drawEnabled) { 990 if (drawEnabled) {
991 fVertices.push_back(2); 991 fVertices.push_back(2);
992 } 992 }
993 } else { // else we have to stop 993 } else { // else we have to stop drawing
994 if (drawEnabled) { 994 if (drawEnabled) {
995 fPoints.push_back(listConfli 995 fPoints.push_back(listConflictPoints[conflictNumber].getValue());
996 orderConflictLineNumber.push 996 orderConflictLineNumber.push_back(fConflictNumHatchLineTab[hatchNumber][conflictNumber]);
997 drawEnabled = false; 997 drawEnabled = false;
998 } 998 }
999 } 999 }
1000 } 1000 }
1001 else { // next point == current 1001 else { // next point == current
1002 bool currentPointCrossLine = fa 1002 bool currentPointCrossLine = false;
1003 bool nextPointCrossLine = false 1003 bool nextPointCrossLine = false;
1004 // if the conflict is on a line 1004 // if the conflict is on a line point, we have to look the hatch number
1005 // of the previous and next poi 1005 // of the previous and next point to see if the hatch had to be draw or not
1006 1006
1007 // test if conflictPoint == fir 1007 // test if conflictPoint == first line point
1008 if (listConflictPoints[conflict 1008 if (listConflictPoints[conflictNumber].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictNumber]].getValue(),FLT_EPSILON*FLT_EPSILON*10)) {
1009 // we look second point hatch 1009 // we look second point hatchNumber
1010 currentPointConflictHatchNumb 1010 currentPointConflictHatchNumber = fHatchShiftToMatchPointVec[fConflictNumHatchLineTab[hatchNumber][conflictNumber]+1];
1011 } 1011 }
1012 else if (listConflictPoints[con 1012 else if (listConflictPoints[conflictNumber].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictNumber]+1].getValue(),FLT_EPSILON*FLT_EPSILON*10)) {
1013 // we look first point hatchN 1013 // we look first point hatchNumber
1014 currentPointConflictHatchNumb 1014 currentPointConflictHatchNumber = fHatchShiftToMatchPointVec[fConflictNumHatchLineTab[hatchNumber][conflictNumber]];
1015 } 1015 }
1016 else { // case of two lines hav 1016 else { // case of two lines have intersection point on a hatch
1017 // it is the same case as a " 1017 // it is the same case as a "end of line" and a "begin of line" conflict
1018 currentPointCrossLine = true; 1018 currentPointCrossLine = true;
1019 currentPointConflictHatchNumb 1019 currentPointConflictHatchNumber =-1 ;
1020 } 1020 }
1021 // test if conflictPoint == sec 1021 // test if conflictPoint == second line point
1022 if (listConflictPoints[conflict 1022 if (listConflictPoints[conflictNumber+1].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictNumber+1]].getValue(),FLT_EPSILON*FLT_EPSILON*10)) {
1023 // we look second point hatch 1023 // we look second point hatchNumber
1024 nextPointConflictHatchNumber 1024 nextPointConflictHatchNumber = fHatchShiftToMatchPointVec[fConflictNumHatchLineTab[hatchNumber][conflictNumber+1]+1];
1025 } 1025 }
1026 else if (listConflictPoints[con 1026 else if (listConflictPoints[conflictNumber+1].equals(listPoints[fConflictNumHatchLineTab[hatchNumber][conflictNumber+1]+1].getValue(),FLT_EPSILON*FLT_EPSILON*10)) {
1027 // we look first point hatchN 1027 // we look first point hatchNumber
1028 nextPointConflictHatchNumber 1028 nextPointConflictHatchNumber = fHatchShiftToMatchPointVec[fConflictNumHatchLineTab[hatchNumber][conflictNumber+1]];
1029 } 1029 }
1030 else { // case of two lines hav 1030 else { // case of two lines have intersection point on a hatch
1031 // it is the same case as a " 1031 // it is the same case as a "end of line" and a "begin of line" conflict
1032 nextPointConflictHatchNumber 1032 nextPointConflictHatchNumber = -1;
1033 nextPointCrossLine = true; 1033 nextPointCrossLine = true;
1034 } 1034 }
1035 1035
1036 // we have to compute the curre 1036 // we have to compute the currentPointConflictHatchNumber and
1037 // nextPointConflictHatchNumber 1037 // nextPointConflictHatchNumber
1038 // if they are all the same sid 1038 // if they are all the same side of the hatch, we have to ignore points
1039 // else, we have to draw a line 1039 // else, we have to draw a line
1040 if (currentPointCrossLine && ne 1040 if (currentPointCrossLine && nextPointCrossLine) {
1041 // do not draw anything, this 1041 // do not draw anything, this is the case of a hatch crossing
1042 // two identical line 1042 // two identical line
1043 } 1043 }
1044 // case of two points on confl 1044 // case of two points on conflict on a contour point where nothing has to be draw
1045 else if ((!currentPointCrossLin 1045 else if ((!currentPointCrossLine && !nextPointCrossLine) && (currentPointConflictHatchNumber == nextPointConflictHatchNumber) && (currentPointConflictHatchNumber == fHatchShiftToMatchPointVec[fConflictNumHatchLineTab[hatchNumber][conflictNumber]])) {
1046 if (drawEnabled) { 1046 if (drawEnabled) {
1047 fPoints.push_back(listConfl 1047 fPoints.push_back(listConflictPoints[conflictNumber].getValue());
1048 orderConflictLineNumber.pus 1048 orderConflictLineNumber.push_back(fConflictNumHatchLineTab[hatchNumber][conflictNumber]);
1049 drawEnabled = false; 1049 drawEnabled = false;
1050 } 1050 }
1051 } 1051 }
1052 // we draw 1052 // we draw
1053 else if( ( (currentPointConflic 1053 else if( ( (currentPointConflictHatchNumber -
1054 fHatchShiftToMatchP 1054 fHatchShiftToMatchPointVec[fConflictNumHatchLineTab[hatchNumber][conflictNumber]]) *
1055 (nextPointConflictHa 1055 (nextPointConflictHatchNumber -
1056 fHatchShiftToMatchP 1056 fHatchShiftToMatchPointVec[fConflictNumHatchLineTab[hatchNumber][conflictNumber]]))
1057 <=FLT_EPSILON) { 1057 <=FLT_EPSILON) {
1058 // try to see if we are tryin 1058 // try to see if we are trying to draw a hatch OVER a contour
1059 unsigned int follow=conflictN 1059 unsigned int follow=conflictNumber+1;
1060 bool overContour = false; 1060 bool overContour = false;
1061 while ((follow <fConflictNumH 1061 while ((follow <fConflictNumHatchLineTab[hatchNumber].size()) &&
1062 (listConflictPoints[co 1062 (listConflictPoints[conflictNumber].equals(listConflictPoints[follow],FLT_EPSILON*FLT_EPSILON*10))) {
1063 follow++; 1063 follow++;
1064 } 1064 }
1065 if(follow < fConflictNumHatch 1065 if(follow < fConflictNumHatchLineTab[hatchNumber].size()) {
1066 float alpha = 0; 1066 float alpha = 0;
1067 bool findAlpha = true; 1067 bool findAlpha = true;
1068 if (listConflictPoints[foll 1068 if (listConflictPoints[follow][0] != listConflictPoints[conflictNumber][0]) {
1069 alpha = (listPoints[fConf 1069 alpha = (listPoints[fConflictNumHatchLineTab[hatchNumber][follow]][0]-listConflictPoints[conflictNumber][0])/(listConflictPoints[follow][0]-listConflictPoints[conflictNumber][0]);
1070 } 1070 }
1071 else if (listConflictPoints 1071 else if (listConflictPoints[follow][1] != listConflictPoints[conflictNumber][1]) {
1072 alpha = (listPoints[fConf 1072 alpha = (listPoints[fConflictNumHatchLineTab[hatchNumber][follow]][1]-listConflictPoints[conflictNumber][1])/(listConflictPoints[follow][1]-listConflictPoints[conflictNumber][1]);
1073 } 1073 }
1074 else if (listConflictPoints 1074 else if (listConflictPoints[follow][2] != listConflictPoints[conflictNumber][2]) {
1075 alpha = (listPoints[fConf 1075 alpha = (listPoints[fConflictNumHatchLineTab[hatchNumber][follow]][2]-listConflictPoints[conflictNumber][2])/(listConflictPoints[follow][2]-listConflictPoints[conflictNumber][2]);
1076 } 1076 }
1077 else { 1077 else {
1078 findAlpha =false; 1078 findAlpha =false;
1079 } 1079 }
1080 if (findAlpha) { 1080 if (findAlpha) {
1081 if ((alpha*(listConflictP 1081 if ((alpha*(listConflictPoints[follow]-listConflictPoints[conflictNumber])).equals(listPoints[fConflictNumHatchLineTab[hatchNumber][follow]]-listConflictPoints[conflictNumber],FLT_EPSILON*FLT_EPSILON*10)) {
1082 overContour = true; 1082 overContour = true;
1083 } 1083 }
1084 } 1084 }
1085 } 1085 }
1086 if (!overContour) { // if we 1086 if (!overContour) { // if we are not on a contour, no problem
1087 fPoints.push_back(listConfl 1087 fPoints.push_back(listConflictPoints[conflictNumber].getValue());
1088 orderConflictLineNumber.pus 1088 orderConflictLineNumber.push_back(fConflictNumHatchLineTab[hatchNumber][conflictNumber]);
1089 drawEnabled = drawEnabled?f 1089 drawEnabled = drawEnabled?false:true;
1090 if (drawEnabled) { 1090 if (drawEnabled) {
1091 fVertices.push_back(2); 1091 fVertices.push_back(2);
1092 } 1092 }
1093 } else { // else we have to s 1093 } else { // else we have to stop drawing
1094 if (drawEnabled) { 1094 if (drawEnabled) {
1095 fPoints.push_back(listCon 1095 fPoints.push_back(listConflictPoints[conflictNumber].getValue());
1096 orderConflictLineNumber.p 1096 orderConflictLineNumber.push_back(fConflictNumHatchLineTab[hatchNumber][conflictNumber]);
1097 drawEnabled = false; 1097 drawEnabled = false;
1098 } 1098 }
1099 } 1099 }
1100 } 1100 }
1101 conflictNumber ++; 1101 conflictNumber ++;
1102 } // end next== current 1102 } // end next== current
1103 } 1103 }
1104 conflictNumber ++; 1104 conflictNumber ++;
1105 } // end while 1105 } // end while
1106 if (drawEnabled) { 1106 if (drawEnabled) {
1107 fPoints.push_back(fPoints[fPoints.s 1107 fPoints.push_back(fPoints[fPoints.size()-1]);
1108 #ifdef TOOLS_HATCHER_DEBUG 1108 #ifdef TOOLS_HATCHER_DEBUG
1109 printf("hatcher : Probably a error 1109 printf("hatcher : Probably a error during conflict resolution on hatch number %d :\nWe have close this line by putting two times the same point.\n\n",hatchNumber);
1110 #endif 1110 #endif
1111 } 1111 }
1112 //re put the order conflictNumHatchLi 1112 //re put the order conflictNumHatchLineTab witch could be use by stripWidth
1113 fConflictNumHatchLineTab[hatchNumber] 1113 fConflictNumHatchLineTab[hatchNumber].clear();
1114 for(unsigned int a=0;a<orderConflictL 1114 for(unsigned int a=0;a<orderConflictLineNumber.size();a++) {
1115 fConflictNumHatchLineTab[hatchNumbe 1115 fConflictNumHatchLineTab[hatchNumber].push_back(orderConflictLineNumber[a]);}
1116 1116
1117 // test if it is correct 1117 // test if it is correct
1118 } // end resolve system errors 1118 } // end resolve system errors
1119 } // end conflict 1119 } // end conflict
1120 } 1120 }
1121 1121
1122 if (fPoints.size() >0){ 1122 if (fPoints.size() >0){
1123 1123
1124 if (precisionError == 0){ 1124 if (precisionError == 0){
1125 delete [] listPoints; 1125 delete [] listPoints;
1126 return true; 1126 return true;
1127 } 1127 }
1128 else { 1128 else {
1129 #ifdef TOOLS_HATCHER_DEBUG 1129 #ifdef TOOLS_HATCHER_DEBUG
1130 printf("hatcher : Exit with %d precisio 1130 printf("hatcher : Exit with %d precision error during compute\n\n",precisionError);
1131 #endif 1131 #endif
1132 delete [] listPoints; 1132 delete [] listPoints;
1133 return false; 1133 return false;
1134 } 1134 }
1135 } 1135 }
1136 delete [] listPoints; 1136 delete [] listPoints;
1137 return true; 1137 return true;
1138 } 1138 }
1139 1139
1140 1140
1141 1141
1142 ///////////////////////////////////////////// 1142 //////////////////////////////////////////////////////////////////////////////
1143 // Compute a vector system equation aA+bB=C 1143 // Compute a vector system equation aA+bB=C
1144 // return vec2f(0,0) if there is an error 1144 // return vec2f(0,0) if there is an error
1145 // set the resolveResult variable to the erro 1145 // set the resolveResult variable to the error code :
1146 // COLINEAR if A and B are 1146 // COLINEAR if A and B are
1147 // PRECISION_ERROR if there is a lack of prec 1147 // PRECISION_ERROR if there is a lack of precision in computing
1148 // Z_ERROR if there s no solution for Z 1148 // Z_ERROR if there s no solution for Z
1149 // UNDEFINED never throw 1149 // UNDEFINED never throw
1150 // return a vec2f for result. a is 'x' value 1150 // return a vec2f for result. a is 'x' value and b is 'y' if it is correct
1151 ///////////////////////////////////////////// 1151 //////////////////////////////////////////////////////////////////////////////
1152 1152
1153 inline vec2f hatcher::resolve_system(const ve 1153 inline vec2f hatcher::resolve_system(const vec3f& A,const vec3f& B,const vec3f& C) {
1154 1154
1155 fResolveResult = RESOLVE_UNDEFINED; 1155 fResolveResult = RESOLVE_UNDEFINED;
1156 1156
1157 double Ax = A[0]; 1157 double Ax = A[0];
1158 double Ay = A[1]; 1158 double Ay = A[1];
1159 double Az = A[2]; 1159 double Az = A[2];
1160 double Bx = B[0]; 1160 double Bx = B[0];
1161 double By = B[1]; 1161 double By = B[1];
1162 double Bz = B[2]; 1162 double Bz = B[2];
1163 double Cx = C[0]; 1163 double Cx = C[0];
1164 double Cy = C[1]; 1164 double Cy = C[1];
1165 double Cz = C[2]; 1165 double Cz = C[2];
1166 1166
1167 double bDiv = (By*Ax-Ay*Bx); 1167 double bDiv = (By*Ax-Ay*Bx);
1168 if (ffabs(float(bDiv)) <=FLT_EPSILON) { 1168 if (ffabs(float(bDiv)) <=FLT_EPSILON) {
1169 // we have to test in a other order 1169 // we have to test in a other order
1170 double tmp; 1170 double tmp;
1171 tmp = Ax; Ax = Ay; Ay = Az; Az = tmp; 1171 tmp = Ax; Ax = Ay; Ay = Az; Az = tmp;
1172 tmp = Bx; Bx = By; By = Bz; Bz = tmp; 1172 tmp = Bx; Bx = By; By = Bz; Bz = tmp;
1173 tmp = Cx; Cx = Cy; Cy = Cz; Cz = tmp; 1173 tmp = Cx; Cx = Cy; Cy = Cz; Cz = tmp;
1174 1174
1175 bDiv = (By*Ax-Ay*Bx); 1175 bDiv = (By*Ax-Ay*Bx);
1176 1176
1177 if (ffabs(float(bDiv)) <=FLT_EPSILON) { 1177 if (ffabs(float(bDiv)) <=FLT_EPSILON) {
1178 // we have to test in a other order 1178 // we have to test in a other order
1179 tmp = Ax; Ax = Ay; Ay = Az; Az = tmp; 1179 tmp = Ax; Ax = Ay; Ay = Az; Az = tmp;
1180 tmp = Bx; Bx = By; By = Bz; Bz = tmp; 1180 tmp = Bx; Bx = By; By = Bz; Bz = tmp;
1181 tmp = Cx; Cx = Cy; Cy = Cz; Cz = tmp; 1181 tmp = Cx; Cx = Cy; Cy = Cz; Cz = tmp;
1182 1182
1183 bDiv = (By*Ax-Ay*Bx); 1183 bDiv = (By*Ax-Ay*Bx);
1184 if (ffabs(float(bDiv)) <=FLT_EPSILON) { 1184 if (ffabs(float(bDiv)) <=FLT_EPSILON) {
1185 fResolveResult = RESOLVE_COLINEAR; 1185 fResolveResult = RESOLVE_COLINEAR;
1186 return vec2f(0,0); 1186 return vec2f(0,0);
1187 } 1187 }
1188 } 1188 }
1189 } 1189 }
1190 double b= (Cy*Ax-Ay*Cx)/bDiv; 1190 double b= (Cy*Ax-Ay*Cx)/bDiv;
1191 double a= -(Cy*Bx-By*Cx)/bDiv; 1191 double a= -(Cy*Bx-By*Cx)/bDiv;
1192 double bid = ffabs(float(a*Az+b*Bz - Cz)); 1192 double bid = ffabs(float(a*Az+b*Bz - Cz));
1193 1193
1194 if (bid <= FLT_EPSILON) { 1194 if (bid <= FLT_EPSILON) {
1195 fResolveResult = RESOLVE_OK; 1195 fResolveResult = RESOLVE_OK;
1196 return vec2f((float)a,(float)b); 1196 return vec2f((float)a,(float)b);
1197 } 1197 }
1198 else { 1198 else {
1199 1199
1200 double minBoxValue = 1; 1200 double minBoxValue = 1;
1201 1201
1202 double minXValue =FLT_MAX; 1202 double minXValue =FLT_MAX;
1203 double minYValue =FLT_MAX; 1203 double minYValue =FLT_MAX;
1204 double minZValue =FLT_MAX; 1204 double minZValue =FLT_MAX;
1205 if ((A[0] !=0) && ((A[0]) <minXValue)) mi 1205 if ((A[0] !=0) && ((A[0]) <minXValue)) minXValue = (A[0]);
1206 if ((B[0] !=0) && ((B[0]) <minXValue)) mi 1206 if ((B[0] !=0) && ((B[0]) <minXValue)) minXValue = (B[0]);
1207 if ((C[0] !=0) && ((C[0]) <minXValue)) mi 1207 if ((C[0] !=0) && ((C[0]) <minXValue)) minXValue = (C[0]);
1208 if ((A[1] !=0) && ((A[1]) <minYValue)) mi 1208 if ((A[1] !=0) && ((A[1]) <minYValue)) minYValue = (A[1]);
1209 if ((B[1] !=0) && ((B[1]) <minYValue)) mi 1209 if ((B[1] !=0) && ((B[1]) <minYValue)) minYValue = (B[1]);
1210 if ((C[1] !=0) && ((C[1]) <minYValue)) mi 1210 if ((C[1] !=0) && ((C[1]) <minYValue)) minYValue = (C[1]);
1211 if ((A[2] !=0) && ((A[2]) <minZValue)) mi 1211 if ((A[2] !=0) && ((A[2]) <minZValue)) minZValue = (A[2]);
1212 if ((B[2] !=0) && ((B[2]) <minZValue)) mi 1212 if ((B[2] !=0) && ((B[2]) <minZValue)) minZValue = (B[2]);
1213 if ((C[2] !=0) && ((C[2]) <minZValue)) mi 1213 if ((C[2] !=0) && ((C[2]) <minZValue)) minZValue = (C[2]);
1214 1214
1215 1215
1216 double maxXValue =-FLT_MAX; 1216 double maxXValue =-FLT_MAX;
1217 double maxYValue =-FLT_MAX; 1217 double maxYValue =-FLT_MAX;
1218 double maxZValue =-FLT_MAX; 1218 double maxZValue =-FLT_MAX;
1219 if ((A[0] !=0) && ((A[0]) >maxXValue)) ma 1219 if ((A[0] !=0) && ((A[0]) >maxXValue)) maxXValue = (A[0]);
1220 if ((B[0] !=0) && ((B[0]) >maxXValue)) ma 1220 if ((B[0] !=0) && ((B[0]) >maxXValue)) maxXValue = (B[0]);
1221 if ((C[0] !=0) && ((C[0]) >maxXValue)) ma 1221 if ((C[0] !=0) && ((C[0]) >maxXValue)) maxXValue = (C[0]);
1222 if ((A[1] !=0) && ((A[1]) >maxYValue)) ma 1222 if ((A[1] !=0) && ((A[1]) >maxYValue)) maxYValue = (A[1]);
1223 if ((B[1] !=0) && ((B[1]) >maxYValue)) ma 1223 if ((B[1] !=0) && ((B[1]) >maxYValue)) maxYValue = (B[1]);
1224 if ((C[1] !=0) && ((C[1]) >maxYValue)) ma 1224 if ((C[1] !=0) && ((C[1]) >maxYValue)) maxYValue = (C[1]);
1225 if ((A[2] !=0) && ((A[2]) >maxZValue)) ma 1225 if ((A[2] !=0) && ((A[2]) >maxZValue)) maxZValue = (A[2]);
1226 if ((B[2] !=0) && ((B[2]) >maxZValue)) ma 1226 if ((B[2] !=0) && ((B[2]) >maxZValue)) maxZValue = (B[2]);
1227 if ((C[2] !=0) && ((C[2]) >maxZValue)) ma 1227 if ((C[2] !=0) && ((C[2]) >maxZValue)) maxZValue = (C[2]);
1228 1228
1229 if (((maxXValue-minXValue) <= (maxYValue- 1229 if (((maxXValue-minXValue) <= (maxYValue-minYValue)) && ((maxXValue-minXValue) <= (maxZValue-minZValue))) { minBoxValue = maxXValue-minXValue; }
1230 else 1230 else
1231 if (((maxYValue-minYValue) <= (maxXValu 1231 if (((maxYValue-minYValue) <= (maxXValue-minXValue)) && ((maxYValue-minYValue) <= (maxZValue-minZValue))) { minBoxValue = maxYValue-minYValue; }
1232 else 1232 else
1233 { minBoxValue = maxZValue-minZValue; 1233 { minBoxValue = maxZValue-minZValue; }
1234 1234
1235 minBoxValue *= fPrecisionFactor; 1235 minBoxValue *= fPrecisionFactor;
1236 1236
1237 if (bid <= minBoxValue) { 1237 if (bid <= minBoxValue) {
1238 fResolveResult = RESOLVE_OK; 1238 fResolveResult = RESOLVE_OK;
1239 return vec2f((float)a,(float)b); 1239 return vec2f((float)a,(float)b);
1240 } 1240 }
1241 else { 1241 else {
1242 if (bid>100*minBoxValue) { 1242 if (bid>100*minBoxValue) {
1243 #ifdef TOOLS_HATCHER_DEBUG 1243 #ifdef TOOLS_HATCHER_DEBUG
1244 printf("hatcher : ***** PRECISON ERRO 1244 printf("hatcher : ***** PRECISON ERROR ON Z ******* compare %f > %f res :%f %f test %f %f bDiv %e\n\n",bid,100*minBoxValue,a,b,a*Ax+b*Bx-Cx,a*Ay+b*By-Cy,bDiv);
1245 #endif 1245 #endif
1246 fResolveResult = RESOLVE_Z_ERROR; 1246 fResolveResult = RESOLVE_Z_ERROR;
1247 } 1247 }
1248 else 1248 else
1249 { 1249 {
1250 #ifdef TOOLS_HATCHER_DEBUG 1250 #ifdef TOOLS_HATCHER_DEBUG
1251 printf("hatcher : ***** PRECISON ER 1251 printf("hatcher : ***** PRECISON ERROR ******* compare %f > %f res :%f %f test %f %f bDiv %e\n\n",bid,100*minBoxValue,a,b,a*Ax+b*Bx-Cx,a*Ay+b*By-Cy,bDiv);
1252 #endif 1252 #endif
1253 fResolveResult = RESOLVE_PRECISION_ 1253 fResolveResult = RESOLVE_PRECISION_ERROR;
1254 } 1254 }
1255 //return vec2f(0,0); //G.Barrand : comm 1255 //return vec2f(0,0); //G.Barrand : commented out to quiet Coverity.
1256 } 1256 }
1257 } 1257 }
1258 return vec2f(0,0); 1258 return vec2f(0,0);
1259 } 1259 }
1260 1260
1261 } 1261 }
1262 1262
1263 //#undef TOOLS_HATCHER_DEBUG 1263 //#undef TOOLS_HATCHER_DEBUG
1264 1264