FreeFOAM The Cross-Platform CFD Toolkit
edgeSurface.C
Go to the documentation of this file.
1 /*---------------------------------------------------------------------------*\
2  ========= |
3  \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
4  \\ / O peration |
5  \\ / A nd | Copyright (C) 1991-2010 OpenCFD Ltd.
6  \\/ M anipulation |
7 -------------------------------------------------------------------------------
8 License
9  This file is part of OpenFOAM.
10 
11  OpenFOAM is free software: you can redistribute it and/or modify it
12  under the terms of the GNU General Public License as published by
13  the Free Software Foundation, either version 3 of the License, or
14  (at your option) any later version.
15 
16  OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
17  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
18  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19  for more details.
20 
21  You should have received a copy of the GNU General Public License
22  along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
23 
24 Description
25 
26 \*---------------------------------------------------------------------------*/
27 
28 #include "edgeSurface.H"
29 #include <triSurface/triSurface.H>
31 #include <meshTools/meshTools.H>
32 #include <OpenFOAM/OFstream.H>
33 
34 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
35 
37 
38 
39 // * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
40 
41 // Write whole pointField and edges to stream
42 void Foam::edgeSurface::writeOBJ
43 (
44  const pointField& points,
45  const edgeList& edges,
46  Ostream& os
47 )
48 {
49  forAll(points, pointI)
50  {
51  const point& pt = points[pointI];
52 
53  os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
54  }
55  forAll(edges, edgeI)
56  {
57  const edge& e = edges[edgeI];
58 
59  os << "l " << e.start()+1 << ' ' << e.end()+1 << endl;
60  }
61 }
62 
63 
64 // Write whole pointField and selected edges to stream
66 (
67  const pointField& points,
68  const edgeList& edges,
69  const labelList& edgeLabels,
70  Ostream& os
71 )
72 {
73  forAll(points, pointI)
74  {
75  const point& pt = points[pointI];
76 
77  os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
78  }
79  forAll(edgeLabels, i)
80  {
81  const edge& e = edges[edgeLabels[i]];
82 
83  os << "l " << e.start()+1 << ' ' << e.end()+1 << endl;
84  }
85 }
86 
87 
88 // Pointedges in edgeSurface indices only.
89 void Foam::edgeSurface::calcPointEdges()
90 {
91  pointEdges_.setSize(points_.size());
92 
93  labelList pointNEdges(points_.size(), 0);
94 
95  forAll(edges_, edgeI)
96  {
97  const edge& e = edges_[edgeI];
98 
99  pointNEdges[e[0]]++;
100  pointNEdges[e[1]]++;
101  }
102 
103  forAll(pointEdges_, pointI)
104  {
105  pointEdges_[pointI].setSize(pointNEdges[pointI]);
106  }
107 
108  pointNEdges = 0;
109 
110  forAll(edges_, edgeI)
111  {
112  const edge& e = edges_[edgeI];
113 
114  labelList& pEdges0 = pointEdges_[e[0]];
115  pEdges0[pointNEdges[e[0]]++] = edgeI;
116 
117  labelList& pEdges1 = pointEdges_[e[1]];
118  pEdges1[pointNEdges[e[1]]++] = edgeI;
119  }
120 }
121 
122 
123 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
124 
125 // Construct from surface and intersection description
127 (
128  const triSurface& surf,
129  const bool isFirstSurface,
130  const surfaceIntersection& inter
131 )
132 :
133  points_(surf.nPoints() + inter.cutPoints().size()),
134  nSurfacePoints_(surf.nPoints()),
135  edges_(),
136  nSurfaceEdges_(surf.nEdges()),
137  parentEdges_(0),
138  faceEdges_(surf.size()),
139  pointEdges_(points_.size())
140 {
141  // Copy points (surface ones first)
142  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
143 
144  label pointI = 0;
145 
146  const pointField& surfPoints = surf.localPoints();
147 
148  forAll(surfPoints, i)
149  {
150  points_[pointI++] = surfPoints[i];
151  }
152 
153  const pointField& cutPoints = inter.cutPoints();
154 
155  forAll(cutPoints, i)
156  {
157  points_[pointI++] = cutPoints[i];
158  }
159 
160 
161  // Copy edges (surface ones first)
162  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
163 
164  DynamicList<edge> allEdges(surf.nEdges() + inter.cutEdges().size());
165  DynamicList<label> allParentEdges(surf.nEdges());
166  List<DynamicList<label> > allFaceEdges(surf.size());
167 
168 
169  // Copy surface edges (can be split!)
170 
171  const edgeList& surfEdges = surf.edges();
172 
173  forAll(surfEdges, edgeI)
174  {
175  const edge& e = surfEdges[edgeI];
176 
177  // Get additional vertices for this edge.
178  const labelList& extraVerts = inter.edgeCuts(isFirstSurface)[edgeI];
179 
180  // Store current top of allEdges.
181  label freeNewEdgeI = allEdges.size();
182 
183  if (extraVerts.empty())
184  {
185  // No cuts across this edge. Note that vertices do not need to be
186  // renumbered.
187  allEdges.append(e);
188  }
189  else
190  {
191  // Edge is cut. From e.start() to extraVerts[0],
192  // from extraVerts[i] to i+1 and finally to e.end().
193  allEdges.append
194  (
195  edge
196  (
197  e.start(),
198  extraVerts[0] + nSurfacePoints_
199  )
200  );
201 
202  for (label extraI = 1; extraI < extraVerts.size(); extraI++)
203  {
204  allEdges.append
205  (
206  edge
207  (
208  extraVerts[extraI-1] + nSurfacePoints_,
209  extraVerts[extraI] + nSurfacePoints_
210  )
211  );
212  }
213  allEdges.append
214  (
215  edge
216  (
217  extraVerts[extraVerts.size()-1] + nSurfacePoints_,
218  e.end()
219  )
220  );
221  }
222 
223  // Update allFaceEdges, parentEdges_ for the newly added edges.
224 
225  // Add each edge label to all face neighbours of edgeI
226  const labelList& myFaces = surf.edgeFaces()[edgeI];
227 
228  for (label eI = freeNewEdgeI; eI < allEdges.size(); eI++)
229  {
230  allParentEdges.append(edgeI);
231 
232  forAll(myFaces, myFaceI)
233  {
234  allFaceEdges[myFaces[myFaceI]].append(eI);
235  }
236  }
237  }
238 
239  // Done all (possibly split) surface edges by now.
240  nSurfaceEdges_ = allEdges.size();
241 
242 
243  // Copy intersection edges
244  // (note no parentEdges)
245  const edgeList& cutEdges = inter.cutEdges();
246 
247  forAll(cutEdges, i)
248  {
249  const edge& e = cutEdges[i];
250 
251  allEdges.append(edge(e[0] + nSurfacePoints_, e[1] + nSurfacePoints_));
252  }
253 
254 
255 
256 
257  // Add intersection edges to faceEdges
258  // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
259 
260  for
261  (
263  iter != inter.facePairToEdge().end();
264  ++iter
265  )
266  {
267  // Edge label in intersection
268  label edgeI = iter();
269 
270  // Get the face from the correct surface
271  const FixedList<label, 2>& twoFaces = iter.key();
272 
273  label faceI;
274 
275  if (isFirstSurface)
276  {
277  faceI = twoFaces[0];
278  }
279  else
280  {
281  faceI = twoFaces[1];
282  }
283 
284  // Store on face-edge addressing. (note: offset edge)
285  allFaceEdges[faceI].append(edgeI + nSurfaceEdges_);
286  }
287 
288  // Transfer.
289  edges_.transfer(allEdges);
290  parentEdges_.transfer(allParentEdges);
291 
292  forAll(allFaceEdges, faceI)
293  {
294  faceEdges_[faceI].transfer(allFaceEdges[faceI]);
295  }
296 
297 
298  // Additional addressing
299  // ~~~~~~~~~~~~~~~~~~~~~
300 
301  calcPointEdges();
302 
303 
304  if (debug & 4)
305  {
306  Pout<< "edgeSurface : Dumping faceEdges to files" << endl;
307 
308  forAll(faceEdges_, faceI)
309  {
310  const labelList& fEdges = faceEdges_[faceI];
311 
312  if (fEdges.size() != 3)
313  {
314  fileName faceFName("face_" + name(faceI) + ".obj");
315  Pout<< "edgeSurface : Dumping faceEdges for face " << faceI
316  << " to " << faceFName << endl;
317 
318  OFstream fStream(faceFName);
319  writeOBJ(points_, edges_, fEdges, fStream);
320  }
321  }
322 
323  Pout<< "edgeSurface : Dumping edges to edges.obj" << endl;
324  OFstream eStream("edges.obj");
325  writeOBJ(points_, edges_, eStream);
326 
327  Pout<< "edgeSurface : Dumping intersectionEdges to"
328  << " intersectionEdges.obj" << endl;
329  OFstream intEdgesStream("intersectionEdges.obj");
330 
331  labelList edgeLabels(edges_.size() - nSurfaceEdges_);
332 
333  label i = 0;
334  for(label edgeI = nSurfaceEdges_; edgeI < edges_.size(); edgeI++)
335  {
336  edgeLabels[i++] = edgeI;
337  }
338 
339  writeOBJ(points_, edges_, edgeLabels, intEdgesStream);
340  }
341 }
342 
343 
344 // * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
345 
347 (
348  const label faceI,
349  const edgeList& additionalEdges
350 )
351 {
352  if (debug & 2)
353  {
354  Pout<< "Old face consisted of edges:" << endl;
355 
356  const labelList& fEdges = faceEdges_[faceI];
357  forAll(fEdges, i)
358  {
359  const edge& e = edges_[fEdges[i]];
360 
361  Pout<< " " << fEdges[i] << ' ' << e
362  << points_[e.start()] << ' ' << points_[e.end()] << endl;
363  }
364  }
365 
366  // Make space for additional intersection edges (copies old ones)
367  const label oldNEdges = edges_.size();
368 
369  edges_.setSize(oldNEdges + additionalEdges.size());
370 
371  // Append new intersection edges
372  label newEdgeI = oldNEdges;
373 
374  forAll(additionalEdges, i)
375  {
376  edges_[newEdgeI] = additionalEdges[i]; // Vertices already in eSurf
377  // indices.
378  newEdgeI++;
379  }
380 
381  // Append to faceEdges.
382  labelList& fEdges = faceEdges_[faceI];
383 
384  label nFEdges = fEdges.size();
385 
386  fEdges.setSize(nFEdges + additionalEdges.size());
387 
388  forAll(additionalEdges, i)
389  {
390  fEdges[nFEdges++] = oldNEdges + i;
391  }
392 
393 
394  // Update pointEdge addressing
395  calcPointEdges();
396 
397 
398  if (debug & 2)
399  {
400  const labelList& fEdges = faceEdges_[faceI];
401 
402  Pout<< "New face consists of edges:" << endl;
403  forAll(fEdges, i)
404  {
405  const edge& e = edges_[fEdges[i]];
406 
407  Pout<< " " << fEdges[i] << ' ' << e
408  << points_[e.start()] << ' ' << points_[e.end()] << endl;
409  }
410  }
411 }
412 
413 
414 // ************************ vim: set sw=4 sts=4 et: ************************ //