int ON_BrepExtrudeVertex(
ON_Brep& brep,
int vertex_index,
const ON_Curve& path_curve
)
{
ON_3dVector path_vector;
if ( vertex_index < 0 && vertex_index >= brep.m_V.Count() )
return false;
if ( !ON_BrepExtrudeHelper_CheckPathCurve(path_curve,path_vector) )
return false;
ON_Curve* c3 = path_curve.Duplicate();
brep.m_V.Reserve( brep.m_V.Count() + 1 );
ON_BrepVertex& v0 = brep.m_V[vertex_index];
ON_BrepVertex& v1 = brep.NewVertex( v0.point + path_vector, 0.0 );
c3->Translate( v0.point - c3->PointAtStart() );
int c3i = brep.AddEdgeCurve( c3 );
ON_BrepEdge& edge = brep.NewEdge( v0, v1, c3i );
edge.m_tolerance = 0.0;
return true;
}
static ON_Brep* MakeTrimmedPlane( ON_TextLog& error_log )
{
// This example demonstrates how to construct a ON_Brep
// with the topology shown below.
//
//
// E-------C--------D
// | /\ |
// | / \ |
// | / \ |
// | e2 e1 |
// | / \ |
// | / \ |
// | / \ |
// A-----e0-------->B
//
//
// Things need to be defined in a valid brep:
// 1- Vertices
// 2- 3D Curves (geometry)
// 3- Edges (topology - reference curve geometry)
// 4- Surface (geometry)
// 5- Faces (topology - reference surface geometry)
// 6- Loops (2D parameter space of faces)
// 4- Trims and 2D curves (2D parameter space of edges)
//
ON_3dPoint point[5] = {
ON_3dPoint( 0.0, 0.0, 0.0 ), // point A = geometry for vertex 0 (and surface SW corner)
ON_3dPoint( 10.0, 0.0, 0.0 ), // point B = geometry for vertex 1 (and surface SE corner)
ON_3dPoint( 5.0, 10.0, 0.0 ), // point C = geometry for vertex 2
ON_3dPoint( 10.0, 10.0, 0.0 ), // point D (surface NE corner)
ON_3dPoint( 0.0, 10.0, 0.0 ), // point E (surface NW corner)
};
ON_Brep* brep = new ON_Brep();
// create three vertices located at the three points
int vi;
for ( vi = 0; vi < 3; vi++ ) {
ON_BrepVertex& v = brep->NewVertex(point[vi]);
v.m_tolerance = 0.0; // this simple example is exact - for models with
// non-exact data, set tolerance as explained in
// definition of ON_BrepVertex.
}
// Create 3d curve geometry - the orientations are arbitrarily chosen
// so that the end vertices are in alphabetical order.
brep->m_C3.Append( CreateLinearCurve( point[A], point[B] ) ); // line AB
brep->m_C3.Append( CreateLinearCurve( point[B], point[C] ) ); // line BC
brep->m_C3.Append( CreateLinearCurve( point[A], point[C] ) ); // line CD
// Create edge topology for each curve in the brep.
CreateEdges( *brep );
// Create 3d surface geometry - the orientations are arbitrarily chosen so
// that some normals point into the cube and others point out of the cube.
brep->m_S.Append( CreatePlanarSurface( point[A], point[B], point[D], point[E] ) ); // ABDE
// Create face topology and 2d parameter space loops and trims.
CreateFaces( *brep );
//Make sure b-rep is valid
if ( !brep->IsValid() )
{
error_log.Print("Trimmed b-rep face is not valid.\n");
delete brep;
brep = NULL;
}
return brep;
}
static ON_Brep *
generate_brep(int count, ON_3dPoint *points)
{
ON_Brep *brep = new ON_Brep();
/* make an arb8 */
// VERTICES
for (int i=0; i<count; i++) {
brep->NewVertex(points[i], SMALL_FASTF);
}
ON_3dPoint p8 = ON_3dPoint(-1.0, 0.0, -1.0);
ON_3dPoint p9 = ON_3dPoint(2.0, 0.0, -1.0);
ON_3dPoint p10 = ON_3dPoint(2.0, 0.0, 3.5);
ON_3dPoint p11 = ON_3dPoint(-1.0, 0.0, 3.5);
brep->NewVertex(p8, SMALL_FASTF); // 8
brep->NewVertex(p9, SMALL_FASTF); // 9
brep->NewVertex(p10, SMALL_FASTF); // 10
brep->NewVertex(p11, SMALL_FASTF); // 11
// LEFT SEGMENTS
// 0
ON_Curve* segment01 = new ON_LineCurve(points[0], points[1]);
segment01->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment01);
// 1
ON_Curve* segment12 = new ON_LineCurve(points[1], points[2]);
segment12->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment12);
// 2
ON_Curve* segment23 = new ON_LineCurve(points[2], points[3]);
segment23->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment23);
// 3
ON_Curve* segment30 = new ON_LineCurve(points[3], points[0]);
segment30->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment30);
// RIGHT SEGMENTS
// 4
ON_Curve* segment45 = new ON_LineCurve(points[5], points[4]);
segment45->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment45);
// 5
ON_Curve* segment56 = new ON_LineCurve(points[6], points[5]);
segment56->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment56);
// 6
ON_Curve* segment67 = new ON_LineCurve(points[7], points[6]);
segment67->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment67);
// 7
ON_Curve* segment74 = new ON_LineCurve(points[4], points[7]);
segment74->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment74);
// HORIZONTAL SEGMENTS
// 8
ON_Curve* segment04 = new ON_LineCurve(points[0], points[4]);
segment04->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment04);
// 9
ON_Curve* segment51 = new ON_LineCurve(points[5], points[1]);
segment51->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment51);
// 10
ON_Curve* segment26 = new ON_LineCurve(points[2], points[6]);
segment26->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment26);
// 11
ON_Curve* segment73 = new ON_LineCurve(points[7], points[3]);
segment73->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment73);
/* XXX */
// 12
ON_Curve* segment01prime = new ON_LineCurve(p8, p9);
segment01prime->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment01prime);
// 13
ON_Curve* segment12prime = new ON_LineCurve(p9, p10);
segment12prime->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment12prime);
// 14
ON_Curve* segment23prime = new ON_LineCurve(p10, p11);
segment23prime->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment23prime);
// 15
ON_Curve* segment30prime = new ON_LineCurve(p11, p8);
segment30prime->SetDomain(0.0, 1.0);
brep->m_C3.Append(segment30prime);
// SURFACES
ON_NurbsSurface* surf0123 = new ON_NurbsSurface(3 /*dimension*/, 0 /*nonrational*/, 2 /*u*/, 2 /*v*/, 2 /*#u*/, 2 /*#v*/);
surf0123->SetKnot(0, 0, 0.0); surf0123->SetKnot(0, 1, 1.0); surf0123->SetKnot(1, 0, 0.0); surf0123->SetKnot(1, 1, 1.0);
surf0123->SetCV(0, 0, points[0]);
surf0123->SetCV(1, 0, points[1]);
surf0123->SetCV(1, 1, points[2]);
surf0123->SetCV(0, 1, points[3]);
brep->m_S.Append(surf0123); /* 0 */
ON_NurbsSurface* surf4765 = new ON_NurbsSurface(3 /*dimension*/, 0 /*nonrational*/, 2 /*u*/, 2 /*v*/, 2 /*#u*/, 2 /*#v*/);
surf4765->SetKnot(0, 0, 0.0); surf4765->SetKnot(0, 1, 1.0); surf4765->SetKnot(1, 0, 0.0); surf4765->SetKnot(1, 1, 1.0);
surf4765->SetCV(0, 0, points[4]);
surf4765->SetCV(1, 0, points[7]);
surf4765->SetCV(1, 1, points[6]);
surf4765->SetCV(0, 1, points[5]);
brep->m_S.Append(surf4765); /* 1 */
ON_NurbsSurface* surf0451 = new ON_NurbsSurface(3 /*dimension*/, 0 /*nonrational*/, 2 /*u*/, 2 /*v*/, 2 /*#u*/, 2 /*#v*/);
surf0451->SetKnot(0, 0, 0.0); surf0451->SetKnot(0, 1, 1.0); surf0451->SetKnot(1, 0, 0.0); surf0451->SetKnot(1, 1, 1.0);
surf0451->SetCV(0, 0, points[0]);
surf0451->SetCV(1, 0, points[4]);
surf0451->SetCV(1, 1, points[5]);
surf0451->SetCV(0, 1, points[1]);
brep->m_S.Append(surf0451); /* 2 */
ON_NurbsSurface* surf2673 = new ON_NurbsSurface(3 /*dimension*/, 0 /*nonrational*/, 2 /*u*/, 2 /*v*/, 2 /*#u*/, 2 /*#v*/);
surf2673->SetKnot(0, 0, 0.0); surf2673->SetKnot(0, 1, 1.0); surf2673->SetKnot(1, 0, 0.0); surf2673->SetKnot(1, 1, 1.0);
surf2673->SetCV(0, 0, points[2]);
surf2673->SetCV(1, 0, points[6]);
surf2673->SetCV(1, 1, points[7]);
surf2673->SetCV(0, 1, points[3]);
brep->m_S.Append(surf2673); /* 3 */
ON_NurbsSurface* surf1562 = new ON_NurbsSurface(3 /*dimension*/, 0 /*nonrational*/, 2 /*u*/, 2 /*v*/, 2 /*#u*/, 2 /*#v*/);
surf1562->SetKnot(0, 0, 0.0); surf1562->SetKnot(0, 1, 1.0); surf1562->SetKnot(1, 0, 0.0); surf1562->SetKnot(1, 1, 1.0);
surf1562->SetCV(0, 0, points[1]);
surf1562->SetCV(1, 0, points[5]);
surf1562->SetCV(1, 1, points[6]);
surf1562->SetCV(0, 1, points[2]);
brep->m_S.Append(surf1562); /* 4 */
ON_NurbsSurface* surf0374 = new ON_NurbsSurface(3 /*dimension*/, 0 /*nonrational*/, 2 /*u*/, 2 /*v*/, 2 /*#u*/, 2 /*#v*/);
surf0374->SetKnot(0, 0, 0.0); surf0374->SetKnot(0, 1, 1.0); surf0374->SetKnot(1, 0, 0.0); surf0374->SetKnot(1, 1, 1.0);
surf0374->SetCV(0, 0, points[0]);
surf0374->SetCV(1, 0, points[3]);
surf0374->SetCV(1, 1, points[7]);
surf0374->SetCV(0, 1, points[4]);
brep->m_S.Append(surf0374); /* 5 */
// TRIM CURVES
ON_Curve* trimcurve01 = new ON_LineCurve(ON_2dPoint(0, 0), ON_2dPoint(1, 0));
trimcurve01->SetDomain(0.0, 1.0);
brep->m_C2.Append(trimcurve01); /* 0 */
ON_Curve* trimcurve12 = new ON_LineCurve(ON_2dPoint(1, 0), ON_2dPoint(1, 1));
trimcurve12->SetDomain(0.0, 1.0);
brep->m_C2.Append(trimcurve12); /* 1 */
ON_Curve* trimcurve23 = new ON_LineCurve(ON_2dPoint(1, 1), ON_2dPoint(0, 1));
trimcurve23->SetDomain(0.0, 1.0);
brep->m_C2.Append(trimcurve23); /* 2 */
ON_Curve* trimcurve30 = new ON_LineCurve(ON_2dPoint(0, 1), ON_2dPoint(0, 0));
trimcurve30->SetDomain(0.0, 1.0);
brep->m_C2.Append(trimcurve30); /* 3 */
// EDGES
/* C3 curve */
// left face edges
brep->NewEdge(brep->m_V[0], brep->m_V[1], 0, NULL, SMALL_FASTF); /* 0 */
brep->NewEdge(brep->m_V[1], brep->m_V[2], 1, NULL, SMALL_FASTF); /* 1 */
brep->NewEdge(brep->m_V[2], brep->m_V[3], 2, NULL, SMALL_FASTF); /* 2 */
brep->NewEdge(brep->m_V[3], brep->m_V[0], 3, NULL, SMALL_FASTF); /* 3 */
// right face edges
brep->NewEdge(brep->m_V[5], brep->m_V[4], 4, NULL, SMALL_FASTF); /* 4 */
brep->NewEdge(brep->m_V[6], brep->m_V[5], 5, NULL, SMALL_FASTF); /* 5 */
brep->NewEdge(brep->m_V[7], brep->m_V[6], 6, NULL, SMALL_FASTF); /* 6 */
brep->NewEdge(brep->m_V[4], brep->m_V[7], 7, NULL, SMALL_FASTF); /* 7 */
// horizontal face edges
brep->NewEdge(brep->m_V[0], brep->m_V[4], 8, NULL, SMALL_FASTF); /* 8 */
brep->NewEdge(brep->m_V[5], brep->m_V[1], 9, NULL, SMALL_FASTF); /* 9 */
brep->NewEdge(brep->m_V[2], brep->m_V[6], 10, NULL, SMALL_FASTF); /* 10 */
brep->NewEdge(brep->m_V[7], brep->m_V[3], 11, NULL, SMALL_FASTF); /* 11 */
// XXX
brep->NewEdge(brep->m_V[8], brep->m_V[9], 12, NULL, SMALL_FASTF); /* 12 */
brep->NewEdge(brep->m_V[9], brep->m_V[10], 13, NULL, SMALL_FASTF); /* 13 */
brep->NewEdge(brep->m_V[10], brep->m_V[11], 14, NULL, SMALL_FASTF); /* 14 */
brep->NewEdge(brep->m_V[11], brep->m_V[8], 15, NULL, SMALL_FASTF); /* 15 */
// FACES
ON_BrepFace& face0123 = brep->NewFace(0);
ON_BrepLoop& loop0123 = brep->NewLoop(ON_BrepLoop::outer, face0123); /* 0 */
ON_BrepTrim& trim01 = brep->NewTrim(brep->m_E[0], false, loop0123, 0 /* trim */); /* m_T[0] */
trim01.m_iso = ON_Surface::S_iso;
trim01.m_type = ON_BrepTrim::mated;
trim01.m_tolerance[0] = SMALL_FASTF;
trim01.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim12 = brep->NewTrim(brep->m_E[1], false, loop0123, 1 /* trim */); /* 1 */
trim12.m_iso = ON_Surface::E_iso;
trim12.m_type = ON_BrepTrim::mated;
trim12.m_tolerance[0] = SMALL_FASTF;
trim12.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim23 = brep->NewTrim(brep->m_E[2], false, loop0123, 2 /* trim */); /* 2 */
trim23.m_iso = ON_Surface::N_iso;
trim23.m_type = ON_BrepTrim::mated;
trim23.m_tolerance[0] = SMALL_FASTF;
trim23.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim30 = brep->NewTrim(brep->m_E[3], false, loop0123, 3 /* trim */); /* 3 */
trim30.m_iso = ON_Surface::W_iso;
trim30.m_type = ON_BrepTrim::mated;
trim30.m_tolerance[0] = SMALL_FASTF;
trim30.m_tolerance[1] = SMALL_FASTF;
ON_BrepFace& face4765 = brep->NewFace(1 /* surfaceID */);
ON_BrepLoop& loop4765 = brep->NewLoop(ON_BrepLoop::outer, face4765); /* 1 */
ON_BrepTrim& trim47 = brep->NewTrim(brep->m_E[7], false, loop4765, 0 /* trim */); /* 4 */
trim47.m_iso = ON_Surface::S_iso;
trim47.m_type = ON_BrepTrim::mated;
trim47.m_tolerance[0] = SMALL_FASTF;
trim47.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim76 = brep->NewTrim(brep->m_E[6], false, loop4765, 1 /* trim */); /* 5 */
trim76.m_iso = ON_Surface::E_iso;
trim76.m_type = ON_BrepTrim::mated;
trim76.m_tolerance[0] = SMALL_FASTF;
trim76.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim65 = brep->NewTrim(brep->m_E[5], false, loop4765, 2 /* trim */); /* 6 */
trim65.m_iso = ON_Surface::N_iso;
trim65.m_type = ON_BrepTrim::mated;
trim65.m_tolerance[0] = SMALL_FASTF;
trim65.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim54 = brep->NewTrim(brep->m_E[4], false, loop4765, 3 /* trim */); /* 7 */
trim54.m_iso = ON_Surface::W_iso;
trim54.m_type = ON_BrepTrim::mated;
trim54.m_tolerance[0] = SMALL_FASTF;
trim54.m_tolerance[1] = SMALL_FASTF;
ON_BrepFace& face0451 = brep->NewFace(2);
ON_BrepLoop& loop0451 = brep->NewLoop(ON_BrepLoop::outer, face0451); /* 2 */
ON_BrepTrim& trim04 = brep->NewTrim(brep->m_E[8], false, loop0451, 0 /* trim */); /* 8 */
trim04.m_iso = ON_Surface::S_iso;
trim04.m_type = ON_BrepTrim::mated;
trim04.m_tolerance[0] = SMALL_FASTF;
trim04.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim45 = brep->NewTrim(brep->m_E[4], true, loop0451, 1 /* trim */); /* 9 */
trim45.m_iso = ON_Surface::E_iso;
trim45.m_type = ON_BrepTrim::mated;
trim45.m_tolerance[0] = SMALL_FASTF;
trim45.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim51 = brep->NewTrim(brep->m_E[9], false, loop0451, 2 /* trim */); /* 10 */
trim51.m_iso = ON_Surface::N_iso;
trim51.m_type = ON_BrepTrim::mated;
trim51.m_tolerance[0] = SMALL_FASTF;
trim51.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim10 = brep->NewTrim(brep->m_E[0], true, loop0451, 3 /* trim */); /* 11 */
trim10.m_iso = ON_Surface::W_iso;
trim10.m_type = ON_BrepTrim::mated;
trim10.m_tolerance[0] = SMALL_FASTF;
trim10.m_tolerance[1] = SMALL_FASTF;
ON_BrepFace& face2673 = brep->NewFace(3);
ON_BrepLoop& loop2673 = brep->NewLoop(ON_BrepLoop::outer, face2673); /* 3 */
ON_BrepTrim& trim26 = brep->NewTrim(brep->m_E[10], false, loop2673, 0 /* trim */); /* 12 */
trim26.m_iso = ON_Surface::S_iso;
trim26.m_type = ON_BrepTrim::mated;
trim26.m_tolerance[0] = SMALL_FASTF;
trim26.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim67 = brep->NewTrim(brep->m_E[6], true, loop2673, 1 /* trim */); /* 13 */
trim67.m_iso = ON_Surface::E_iso;
trim67.m_type = ON_BrepTrim::mated;
trim67.m_tolerance[0] = SMALL_FASTF;
trim67.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim73 = brep->NewTrim(brep->m_E[11], false, loop2673, 2 /* trim */); /* 14 */
trim73.m_iso = ON_Surface::N_iso;
trim73.m_type = ON_BrepTrim::mated;
trim73.m_tolerance[0] = SMALL_FASTF;
trim73.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim32 = brep->NewTrim(brep->m_E[2], true, loop2673, 3 /* trim */); /* 15 */
trim32.m_iso = ON_Surface::W_iso;
trim32.m_type = ON_BrepTrim::mated;
trim32.m_tolerance[0] = SMALL_FASTF;
trim32.m_tolerance[1] = SMALL_FASTF;
ON_BrepFace& face1562 = brep->NewFace(4);
ON_BrepLoop& loop1562 = brep->NewLoop(ON_BrepLoop::outer, face1562); /* 4 */
ON_BrepTrim& trim15 = brep->NewTrim(brep->m_E[9], true, loop1562, 0 /* trim */); /* 16 */
trim15.m_iso = ON_Surface::S_iso;
trim15.m_type = ON_BrepTrim::mated;
trim15.m_tolerance[0] = SMALL_FASTF;
trim15.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim56 = brep->NewTrim(brep->m_E[5], true, loop1562, 1 /* trim */); /* 17 */
trim56.m_iso = ON_Surface::E_iso;
trim56.m_type = ON_BrepTrim::mated;
trim56.m_tolerance[0] = SMALL_FASTF;
trim56.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim62 = brep->NewTrim(brep->m_E[10], true, loop1562, 2 /* trim */); /* 18 */
trim62.m_iso = ON_Surface::N_iso;
trim62.m_type = ON_BrepTrim::mated;
trim62.m_tolerance[0] = SMALL_FASTF;
trim62.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim21 = brep->NewTrim(brep->m_E[1], true, loop1562, 3 /* trim */); /* 19 */
trim21.m_iso = ON_Surface::W_iso;
trim21.m_type = ON_BrepTrim::mated;
trim21.m_tolerance[0] = SMALL_FASTF;
trim21.m_tolerance[1] = SMALL_FASTF;
ON_BrepFace& face0374 = brep->NewFace(5);
ON_BrepLoop& loop0374 = brep->NewLoop(ON_BrepLoop::outer, face0374); /* 5 */
ON_BrepTrim& trim03 = brep->NewTrim(brep->m_E[3], true, loop0374, 0 /* trim */); /* 20 */
trim03.m_iso = ON_Surface::S_iso;
trim03.m_type = ON_BrepTrim::mated;
trim03.m_tolerance[0] = SMALL_FASTF;
trim03.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim37 = brep->NewTrim(brep->m_E[11], true, loop0374, 1 /* trim */); /* 21 */
trim37.m_iso = ON_Surface::E_iso;
trim37.m_type = ON_BrepTrim::mated;
trim37.m_tolerance[0] = SMALL_FASTF;
trim37.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim74 = brep->NewTrim(brep->m_E[7], true, loop0374, 2 /* trim */); /* 22 */
trim74.m_iso = ON_Surface::N_iso;
trim74.m_type = ON_BrepTrim::mated;
trim74.m_tolerance[0] = SMALL_FASTF;
trim74.m_tolerance[1] = SMALL_FASTF;
ON_BrepTrim& trim40 = brep->NewTrim(brep->m_E[8], true, loop0374, 3 /* trim */); /* 23 */
trim40.m_iso = ON_Surface::W_iso;
trim40.m_type = ON_BrepTrim::mated;
trim40.m_tolerance[0] = SMALL_FASTF;
trim40.m_tolerance[1] = SMALL_FASTF;
return brep;
}
ON_Brep*
MakeTwistedCube(ON_TextLog& error_log)
{
ON_3dPoint point[8] = {
ON_3dPoint( 0.0, 0.0, 11.0), // Point A
ON_3dPoint(10.0, 0.0, 12.0), // Point B
ON_3dPoint(10.0, 8.0, 13.0), // Point C
ON_3dPoint( 0.0, 6.0, 12.0), // Point D
ON_3dPoint( 1.0, 2.0, 0.0), // Point E
ON_3dPoint(10.0, 0.0, 0.0), // Point F
ON_3dPoint(10.0, 7.0, -1.0), // Point G
ON_3dPoint( 0.0, 6.0, 0.0), // Point H
};
ON_Brep* brep = new ON_Brep();
// create eight vertices located at the eight points
for (int i = 0; i < 8; i++) {
ON_BrepVertex& v = brep->NewVertex(point[i]);
v.m_tolerance = 0.0;
// this example uses exact tolerance... reference
// ON_BrepVertex for definition of non-exact data
}
// create 3d curve geometry - the orientations are arbitrarily
// chosen so that the end vertices are in alphabetical order
brep->m_C3.Append(TwistedCubeEdgeCurve(point[A], point[B])); // AB
brep->m_C3.Append(TwistedCubeEdgeCurve(point[B], point[C])); // BC
brep->m_C3.Append(TwistedCubeEdgeCurve(point[C], point[D])); // CD
brep->m_C3.Append(TwistedCubeEdgeCurve(point[A], point[D])); // AD
brep->m_C3.Append(TwistedCubeEdgeCurve(point[E], point[F])); // EF
brep->m_C3.Append(TwistedCubeEdgeCurve(point[F], point[G])); // FG
brep->m_C3.Append(TwistedCubeEdgeCurve(point[G], point[H])); // GH
brep->m_C3.Append(TwistedCubeEdgeCurve(point[E], point[H])); // EH
brep->m_C3.Append(TwistedCubeEdgeCurve(point[A], point[E])); // AE
brep->m_C3.Append(TwistedCubeEdgeCurve(point[B], point[F])); // BF
brep->m_C3.Append(TwistedCubeEdgeCurve(point[C], point[G])); // CG
brep->m_C3.Append(TwistedCubeEdgeCurve(point[D], point[H])); // DH
// create the 12 edges the connect the corners
MakeTwistedCubeEdges( *brep );
// create the 3d surface geometry. the orientations are arbitrary so
// some normals point into the cube and other point out... not sure why
brep->m_S.Append(TwistedCubeSideSurface(point[A], point[B], point[C], point[D]));
brep->m_S.Append(TwistedCubeSideSurface(point[B], point[F], point[G], point[C]));
brep->m_S.Append(TwistedCubeSideSurface(point[F], point[E], point[H], point[G]));
brep->m_S.Append(TwistedCubeSideSurface(point[E], point[A], point[D], point[H]));
brep->m_S.Append(TwistedCubeSideSurface(point[E], point[F], point[B], point[A]));
brep->m_S.Append(TwistedCubeSideSurface(point[D], point[C], point[G], point[H]));
// create the faces
MakeTwistedCubeFaces(*brep);
if (!brep->IsValid()) {
error_log.Print("Twisted cube b-rep is not valid!\n");
delete brep;
brep = NULL;
}
return brep;
}
static
bool SplitSeam( ON_Brep& brep,
ON_BrepTrim& trimA, ON_BrepTrim& trimB,
ON_BrepTrim& prevtrimB,
ON_BrepTrim& nexttrimB,
int vcount0 // number of verts before singular fixups
)
{
if ( trimA.m_trim_index == trimB.m_trim_index )
return false;
if ( trimA.m_trim_index == prevtrimB.m_trim_index )
return false;
if ( trimA.m_trim_index == nexttrimB.m_trim_index )
return false;
if ( trimB.m_trim_index == prevtrimB.m_trim_index )
return false;
if ( trimB.m_trim_index == nexttrimB.m_trim_index )
return false;
if ( prevtrimB.m_trim_index == nexttrimB.m_trim_index )
return false;
if ( trimA.m_type != ON_BrepTrim::seam )
return false;
if ( trimB.m_type != ON_BrepTrim::seam )
return false;
if ( trimA.m_ei != trimB.m_ei )
return false;
if ( trimA.m_vi[0] != trimB.m_vi[1]
&& trimA.m_vi[0] < vcount0
&& trimB.m_vi[1] < vcount0 )
return false;
if ( trimA.m_vi[1] != trimB.m_vi[0]
&& trimA.m_vi[1] < vcount0
&& trimB.m_vi[0] < vcount0 )
return false;
if ( prevtrimB.m_vi[1] != trimB.m_vi[0]
&& prevtrimB.m_vi[1] < vcount0
&& trimB.m_vi[0] < vcount0 )
return false;
if ( nexttrimB.m_vi[0] != trimB.m_vi[1]
&& prevtrimB.m_vi[0] < vcount0
&& trimB.m_vi[1] < vcount0 )
return false;
if ( trimA.m_li != trimB.m_li )
return false;
if ( trimA.m_li != prevtrimB.m_li )
return false;
if ( trimA.m_li != nexttrimB.m_li )
return false;
if ( trimA.m_bRev3d == trimB.m_bRev3d )
return false;
const ON_Surface* srf = trimA.SurfaceOf();
if ( 0 == srf )
return false;
ON_BrepEdge* edgeA = brep.Edge(trimA.m_ei);
if ( 0 == edgeA )
return false;
if ( edgeA->m_ti.Count() != 2 )
return false;
if ( edgeA->m_ti[0] != trimA.m_trim_index && edgeA->m_ti[1] != trimA.m_trim_index )
return false;
if ( edgeA->m_ti[0] != trimB.m_trim_index && edgeA->m_ti[1] != trimB.m_trim_index )
return false;
// reserve space now so the vA0 and vA1 pointers
// will be valid if m_V[] is grown.
brep.m_V.Reserve( brep.m_V.Count()+2 );
ON_BrepVertex* vA0 = brep.Vertex(trimA.m_vi[0]);
if ( 0 == vA0 )
return false;
ON_BrepVertex* vA1 = brep.Vertex(trimA.m_vi[1]);
if ( 0 == vA1 )
return false;
// looks like we have a valid seam to blow apart
// get a new 3d curve for trimB
ON_Curve* cB3 = PushUpIsoTrim( brep, trimB );
if ( 0 == cB3 )
return false;
int c3i = brep.AddEdgeCurve(cB3);
vA0->m_tolerance = ON_UNSET_VALUE;
vA1->m_tolerance = ON_UNSET_VALUE;
// make new vertices for trimB
ON_BrepVertex* vB0 = 0;
ON_BrepVertex* vB1 = 0;
ON_3dPoint PA, PB;
bool bSame = false;
if (brep.GetTrim3dStart(trimB.m_trim_index, PB) && brep.GetTrim3dEnd(trimA.m_trim_index, PA))
bSame = PB.DistanceTo(PA) < ON_ZERO_TOLERANCE;
if (bSame || trimB.m_vi[0] != trimA.m_vi[1] )
{
// sing fixups have already blown apart this end
vB0 = brep.Vertex( trimB.m_vi[0] );
}
bSame = false;
if (brep.GetTrim3dStart(trimA.m_trim_index, PA) && brep.GetTrim3dEnd(trimB.m_trim_index, PB))
bSame = PB.DistanceTo(PA) < ON_ZERO_TOLERANCE;
if (bSame || trimB.m_vi[1] != trimA.m_vi[0] )
{
// sing fixups have already blown apart this end
vB1 = brep.Vertex( trimB.m_vi[1] );
}
if ( 0 == vB0 )
{
ON_BrepVertex& v = brep.NewVertex();
vB0 = &v;
trimB.m_vi[0] = vB0->m_vertex_index;
}
if ( 0 == vB1 )
{
ON_BrepVertex& v = brep.NewVertex();
vB1 = &v;
trimB.m_vi[1] = vB1->m_vertex_index;
}
// disconnect edgeA and trimB
trimB.m_ei = -1;
if ( edgeA->m_ti[0] == trimB.m_trim_index )
edgeA->m_ti.Remove(0);
else if ( edgeA->m_ti[1] == trimB.m_trim_index )
edgeA->m_ti.Remove(1);
ChangeTrimVertex( brep, trimB, 0, vA1->m_vertex_index, vB0->m_vertex_index, true, true );
ChangeTrimVertex( brep, trimB, 1, vA0->m_vertex_index, vB1->m_vertex_index, true, true );
ChangeTrimVertex( brep, prevtrimB, 1, vA1->m_vertex_index, vB0->m_vertex_index, true, true );
ChangeTrimVertex( brep, nexttrimB, 0, vA0->m_vertex_index, vB1->m_vertex_index, true, true );
// make a new edgeB and connect it to trimB
ON_BrepEdge& edgeB = brep.NewEdge( *vB0, *vB1, c3i );
edgeA = 0; // pointer may be invalid after m_E[] grows
edgeB.m_ti.Append(trimB.m_trim_index);
trimB.m_ei = edgeB.m_edge_index;
trimB.m_bRev3d = false;
trimA.m_type = ON_BrepTrim::boundary;
trimB.m_type = ON_BrepTrim::boundary;
return true;
}
static
bool ChangeTrimBdryToSing( ON_Brep& brep, ON_BrepTrim& trim,
ON_BrepTrim* prevtrim, ON_BrepTrim* nexttrim )
{
if ( trim.m_vi[0] == trim.m_vi[1] )
return false;
if ( trim.m_type == ON_BrepTrim::singular )
return false;
if ( trim.m_ei < 0 )
return false;
int vi0 = trim.m_vi[0];
int vi1 = trim.m_vi[1];
int sing_vi = vi0;
ON_BrepVertex* v0 = brep.Vertex(vi0);
if ( v0 )
v0->m_tolerance = ON_UNSET_VALUE;
ON_BrepVertex* v1 = brep.Vertex(vi1);
if ( v1 )
v1->m_tolerance = ON_UNSET_VALUE;
ON_BrepEdge* edge = brep.Edge(trim.m_ei);
if ( edge )
{
for ( int eti = 0; eti < edge->m_ti.Count(); eti++ )
{
if ( edge->m_ti[eti] == trim.m_trim_index )
{
edge->m_ti.Remove(eti);
break;
}
}
trim.m_ei = -1;
if ( 0 == edge->m_ti.Count() )
{
brep.DeleteEdge( *edge, true );
}
else if ( 1 == edge->m_ti.Count() && ON_BrepTrim::seam == trim.m_type )
{
// change neighbor trim type
ON_BrepTrim* other_trim = brep.Trim(edge->m_ti[0]);
if ( 0 != other_trim && ON_BrepTrim::seam == other_trim->m_type )
{
other_trim->m_type = ON_BrepTrim::boundary;
int j = (trim.m_bRev3d == other_trim->m_bRev3d) ? 0 : 1;
if ( trim.m_vi[0] == other_trim->m_vi[j]
&& trim.m_vi[1] == other_trim->m_vi[1-j] )
{
// we need a new singular vertex
sing_vi = brep.NewVertex(ON_UNSET_POINT).m_vertex_index;
}
}
}
}
trim.m_vi[0] = sing_vi;
trim.m_vi[1] = sing_vi;
trim.m_type = ON_BrepTrim::singular;
trim.m_bRev3d = false;
if ( nexttrim )
ChangeTrimVertex( brep,*nexttrim,0,vi1,sing_vi,true,true);
if ( prevtrim )
ChangeTrimVertex( brep,*prevtrim,1,vi0,sing_vi,true,true);
return true;
}
static
bool ChangeTrimSingToBdry( ON_Brep& brep, ON_BrepTrim& trim, ON_BrepTrim* nexttrim )
{
if ( trim.m_vi[0] != trim.m_vi[1] )
return false;
if ( trim.m_type != ON_BrepTrim::singular )
return false;
if ( trim.m_ei >= 0 )
return false;
const ON_Surface* srf = trim.SurfaceOf();
if ( 0 == srf )
return false;
brep.m_V.Reserve( brep.m_V.Count() + 1 );
ON_BrepVertex* v0 = brep.Vertex(trim.m_vi[0]);
if ( 0 == v0 )
return false;
// get new 3d curve
ON_Curve* c3 = PushUpIsoTrim( brep, trim );
if ( 0 == c3 )
return false;
// valid singular trim can be changed to non-singular trim
// create new vertex for end of this trim
v0->m_tolerance = ON_UNSET_VALUE;
ON_BrepVertex* v1 = 0;
if ( c3->IsClosed() )
{
// 3d edge is closed so start and end vertex are still the same.
v1 = v0;
}
else
{
// new 3d edge is not closed, so the single singular vertex
// needs to be "split" into two vertices.
brep.NewVertex();
v1 = brep.m_V.Last();
}
trim.m_vi[1] = v1->m_vertex_index;
// update the start of the next trim to use new vertex
if ( nexttrim && nexttrim->m_trim_index != trim.m_trim_index )
{
ChangeTrimVertex( brep, *nexttrim, 0, v0->m_vertex_index, v1->m_vertex_index, true, true );
}
// make a new edge
int ci = brep.AddEdgeCurve(c3);
c3 = 0;
ON_BrepEdge& edge = brep.NewEdge(*v0,*v1,ci);
edge.m_tolerance = 0.0;
// hook trim to new edge
trim.m_type = ON_BrepTrim::boundary;
trim.m_bRev3d = false;
trim.m_ei = edge.m_edge_index;
edge.m_ti.Append(trim.m_trim_index);
return true;
}
static ON_Brep* MakeTwistedCube( ON_TextLog& error_log )
{
// This example demonstrates how to construct a ON_Brep
// with the topology shown below.
//
//
// H-------e6-------G
// / /|
// / | / |
// / e7 / e5
// / | / |
// / e10 |
// / | / |
// e11 E- - e4- -/- - - F
// / / /
// / / / /
// D---------e2-----C e9
// | / | /
// | e8 | /
// e3 / e1 /
// | | /
// | / | /
// | |/
// A-------e0-------B
//
//
ON_3dPoint point[8] = {
ON_3dPoint( 0.0, 0.0, 0.0 ), // point A = geometry for vertex 0
ON_3dPoint( 10.0, 0.0, 0.0 ), // point B = geometry for vertex 1
ON_3dPoint( 10.0, 8.0, -1.0 ), // point C = geometry for vertex 2
ON_3dPoint( 0.0, 6.0, 0.0 ), // point D = geometry for vertex 3
ON_3dPoint( 1.0, 2.0, 11.0 ), // point E = geometry for vertex 4
ON_3dPoint( 10.0, 0.0, 12.0 ), // point F = geometry for vertex 5
ON_3dPoint( 10.0, 7.0, 13.0 ), // point G = geometry for vertex 6
ON_3dPoint( 0.0, 6.0, 12.0 ) // point H = geometry for vertex 7
};
ON_Brep* brep = new ON_Brep();
// create eight vertices located at the eight points
int vi;
for ( vi = 0; vi < 8; vi++ ) {
ON_BrepVertex& v = brep->NewVertex(point[vi]);
v.m_tolerance = 0.0; // this simple example is exact - for models with
// non-exact data, set tolerance as explained in
// definition of ON_BrepVertex.
}
// Create 3d curve geometry - the orientations are arbitrarily chosen
// so that the end vertices are in alphabetical order.
brep->m_C3.Append( TwistedCubeEdgeCurve( point[A], point[B] ) ); // line AB
brep->m_C3.Append( TwistedCubeEdgeCurve( point[B], point[C] ) ); // line BC
brep->m_C3.Append( TwistedCubeEdgeCurve( point[C], point[D] ) ); // line CD
brep->m_C3.Append( TwistedCubeEdgeCurve( point[A], point[D] ) ); // line AD
brep->m_C3.Append( TwistedCubeEdgeCurve( point[E], point[F] ) ); // line EF
brep->m_C3.Append( TwistedCubeEdgeCurve( point[F], point[G] ) ); // line FG
brep->m_C3.Append( TwistedCubeEdgeCurve( point[G], point[H] ) ); // line GH
brep->m_C3.Append( TwistedCubeEdgeCurve( point[E], point[H] ) ); // line EH
brep->m_C3.Append( TwistedCubeEdgeCurve( point[A], point[E] ) ); // line AE
brep->m_C3.Append( TwistedCubeEdgeCurve( point[B], point[F] ) ); // line BF
brep->m_C3.Append( TwistedCubeEdgeCurve( point[C], point[G] ) ); // line CG
brep->m_C3.Append( TwistedCubeEdgeCurve( point[D], point[H] ) ); // line DH
// Create the 12 edges that connect the corners of the cube.
MakeTwistedCubeEdges( *brep );
// Create 3d surface geometry - the orientations are arbitrarily chosen so
// that some normals point into the cube and others point out of the cube.
brep->m_S.Append( TwistedCubeSideSurface( point[A], point[B], point[C], point[D] ) ); // ABCD
brep->m_S.Append( TwistedCubeSideSurface( point[B], point[C], point[G], point[F] ) ); // BCGF
brep->m_S.Append( TwistedCubeSideSurface( point[C], point[D], point[H], point[G] ) ); // CDHG
brep->m_S.Append( TwistedCubeSideSurface( point[A], point[D], point[H], point[E] ) ); // ADHE
brep->m_S.Append( TwistedCubeSideSurface( point[A], point[B], point[F], point[E] ) ); // ABFE
brep->m_S.Append( TwistedCubeSideSurface( point[E], point[F], point[G], point[H] ) ); // EFGH
// Create the CRhinoBrepFaces
MakeTwistedCubeFaces( *brep );
if ( !brep->IsValid() )
{
error_log.Print("Twisted cube b-rep is not valid.\n");
delete brep;
brep = NULL;
}
//ON_BOOL32 bIsManifold;
//ON_BOOL32 bHasBoundary;
//ON_BOOL32 b = brep->IsManifold( &bIsManifold,&bHasBoundary );
return brep;
}
bool ON_BrepExtrude(
ON_Brep& brep,
const ON_Curve& path_curve,
bool bCap
)
{
ON_Workspace ws;
const int vcount0 = brep.m_V.Count();
const int tcount0 = brep.m_T.Count();
const int lcount0 = brep.m_L.Count();
const int ecount0 = brep.m_E.Count();
const int fcount0 = brep.m_F.Count();
const ON_3dPoint PathStart = path_curve.PointAtStart();
ON_3dPoint P = path_curve.PointAtEnd();
if ( !PathStart.IsValid() || !P.IsValid() )
return false;
const ON_3dVector height = P - PathStart;
if ( !height.IsValid() || height.Length() <= ON_ZERO_TOLERANCE )
return false;
ON_Xform tr;
tr.Translation(height);
// count number of new sides
int side_count = 0;
int i, vi, ei, fi;
bool* bSideEdge = (bool*)ws.GetIntMemory(ecount0*sizeof(bSideEdge[0]));
for ( ei = 0; ei < ecount0; ei++ )
{
const ON_BrepEdge& e = brep.m_E[ei];
if ( 1 == e.m_ti.Count() )
{
side_count++;
bSideEdge[ei] = true;
}
else
{
bSideEdge[ei] = false;
}
}
brep.m_V.Reserve( 2*vcount0 );
i = 4*side_count + (bCap?tcount0:0);
brep.m_T.Reserve( tcount0 + i );
brep.m_C2.Reserve( brep.m_C2.Count() + i );
brep.m_L.Reserve( lcount0 + side_count + (bCap?lcount0:0) );
i = side_count + (bCap?ecount0:side_count);
brep.m_E.Reserve( ecount0 + i );
brep.m_C3.Reserve( brep.m_C3.Count() + i );
i = side_count + (bCap?fcount0:0);
brep.m_F.Reserve( fcount0 + i );
brep.m_S.Reserve( brep.m_S.Count() + i );
bool bOK = true;
// build top vertices
int* topvimap = ws.GetIntMemory(vcount0);
memset(topvimap,0,vcount0*sizeof(topvimap[0]));
if ( bCap )
{
for ( vi = 0; vi < vcount0; vi++ )
{
const ON_BrepVertex& bottomv = brep.m_V[vi];
ON_BrepVertex& topv = brep.NewVertex(bottomv.point+height,bottomv.m_tolerance);
topvimap[vi] = topv.m_vertex_index;
}
}
else
{
for ( ei = 0; ei < ecount0; ei++ )
{
if ( bSideEdge[ei] )
{
const ON_BrepEdge& bottome = brep.m_E[ei];
int bottomvi0 = bottome.m_vi[0];
if ( bottomvi0 < 0 || bottomvi0 >= vcount0 )
{
bOK = false;
break;
}
int bottomvi1 = bottome.m_vi[1];
if ( bottomvi1 < 0 || bottomvi1 >= vcount0 )
{
bOK = false;
break;
}
if ( !topvimap[bottomvi0] )
{
const ON_BrepVertex& bottomv = brep.m_V[bottomvi0];
ON_BrepVertex& topv = brep.NewVertex(bottomv.point+height,bottomv.m_tolerance);
topvimap[bottomvi0] = topv.m_vertex_index;
}
if ( !topvimap[bottomvi1] )
{
const ON_BrepVertex& bottomv = brep.m_V[bottomvi1];
ON_BrepVertex& topv = brep.NewVertex(bottomv.point+height,bottomv.m_tolerance);
topvimap[bottomvi1] = topv.m_vertex_index;
}
}
}
}
// build top edges
int* topeimap = ws.GetIntMemory(ecount0);
memset(topeimap,0,ecount0*sizeof(topeimap[0]));
if ( bOK ) for ( ei = 0; ei < ecount0; ei++ )
{
if ( bCap || bSideEdge[ei] )
{
const ON_BrepEdge& bottome = brep.m_E[ei];
ON_BrepVertex& topv0 = brep.m_V[topvimap[bottome.m_vi[0]]];
ON_BrepVertex& topv1 = brep.m_V[topvimap[bottome.m_vi[1]]];
ON_Curve* c3 = bottome.DuplicateCurve();
if ( !c3 )
{
bOK = false;
break;
}
c3->Transform(tr);
int c3i = brep.AddEdgeCurve(c3);
ON_BrepEdge& tope = brep.NewEdge(topv0,topv1,c3i,0,bottome.m_tolerance);
topeimap[ei] = tope.m_edge_index;
}
}
// build side edges
int* sideveimap = ws.GetIntMemory(vcount0);
memset(sideveimap,0,vcount0*sizeof(sideveimap[0]));
if ( bOK ) for ( vi = 0; vi < vcount0; vi++ )
{
ON_BrepVertex& bottomv = brep.m_V[vi];
for ( int vei = 0; vei < bottomv.m_ei.Count(); vei++ )
{
if ( bSideEdge[bottomv.m_ei[vei]] && topvimap[vi] )
{
ON_BrepVertex& topv = brep.m_V[topvimap[vi]];
ON_Curve* c3 = path_curve.DuplicateCurve();
if ( !c3 )
{
bOK = false;
}
else
{
ON_3dVector D = bottomv.point - PathStart;
c3->Translate(D);
int c3i = brep.AddEdgeCurve(c3);
const ON_BrepEdge& e = brep.NewEdge(bottomv,topv,c3i,0,0.0);
sideveimap[vi] = e.m_edge_index;
}
break;
}
}
}
if ( bOK && bCap )
{
// build top faces
for (fi = 0; fi < fcount0; fi++ )
{
const ON_BrepFace& bottomf = brep.m_F[fi];
ON_Surface* srf = bottomf.DuplicateSurface();
if ( !srf )
{
bOK = false;
break;
}
srf->Transform(tr);
int si = brep.AddSurface(srf);
ON_BrepFace& topf = brep.NewFace(si);
topf.m_bRev = !bottomf.m_bRev;
const int loop_count = bottomf.m_li.Count();
topf.m_li.Reserve(loop_count);
for ( int fli = 0; fli < loop_count; fli++ )
{
const ON_BrepLoop& bottoml = brep.m_L[bottomf.m_li[fli]];
ON_BrepLoop& topl = brep.NewLoop(bottoml.m_type,topf);
const int loop_trim_count = bottoml.m_ti.Count();
topl.m_ti.Reserve(loop_trim_count);
for ( int lti = 0; lti < loop_trim_count; lti++ )
{
const ON_BrepTrim& bottomt = brep.m_T[bottoml.m_ti[lti]];
ON_NurbsCurve* c2 = ON_NurbsCurve::New();
if ( !bottomt.GetNurbForm(*c2) )
{
delete c2;
bOK = false;
break;
}
int c2i = brep.AddTrimCurve(c2);
ON_BrepTrim* topt = 0;
if ( bottomt.m_ei >= 0 )
{
ON_BrepEdge& tope = brep.m_E[topeimap[bottomt.m_ei]];
topt = &brep.NewTrim(tope,bottomt.m_bRev3d,topl,c2i);
}
else
{
// singular trim
ON_BrepVertex& topv = brep.m_V[topvimap[bottomt.m_vi[0]]];
topt = &brep.NewSingularTrim(topv,topl,bottomt.m_iso,c2i);
}
topt->m_tolerance[0] = bottomt.m_tolerance[0];
topt->m_tolerance[1] = bottomt.m_tolerance[1];
topt->m_pbox = bottomt.m_pbox;
topt->m_type = bottomt.m_type;
topt->m_iso = bottomt.m_iso;
}
topl.m_pbox = bottoml.m_pbox;
}
}
}
// build sides
int bRev3d[4] = {0,0,1,1};
int vid[4], eid[4];
if( bOK ) for ( ei = 0; ei < ecount0; ei++ )
{
if ( bSideEdge[ei] && topeimap[ei] )
{
ON_BrepEdge& bottome = brep.m_E[ei];
ON_BrepEdge& tope = brep.m_E[topeimap[ei]];
vid[0] = bottome.m_vi[0];
vid[1] = bottome.m_vi[1];
vid[2] = topvimap[vid[1]];
vid[3] = topvimap[vid[0]];
if ( sideveimap[vid[0]] && sideveimap[vid[1]] )
{
ON_BrepEdge& leftedge = brep.m_E[sideveimap[vid[0]]];
ON_BrepEdge& rightedge = brep.m_E[sideveimap[vid[1]]];
ON_Curve* cx = bottome.DuplicateCurve();
if ( !cx )
{
bOK = false;
break;
}
ON_Curve* cy = leftedge.DuplicateCurve();
if ( !cy )
{
delete cx;
bOK = false;
break;
}
ON_SumSurface* srf = new ON_SumSurface();
srf->m_curve[0] = cx;
srf->m_curve[1] = cy;
srf->m_basepoint = srf->m_curve[1]->PointAtStart();
srf->m_basepoint.x = -srf->m_basepoint.x;
srf->m_basepoint.y = -srf->m_basepoint.y;
srf->m_basepoint.z = -srf->m_basepoint.z;
eid[0] = bottome.m_edge_index;
eid[1] = rightedge.m_edge_index;
eid[2] = tope.m_edge_index;
eid[3] = leftedge.m_edge_index;
ON_BrepFace* face = brep.NewFace(srf,vid,eid,bRev3d);
if ( !face )
{
bOK = false;
break;
}
else if ( bottome.m_ti.Count() == 2 )
{
const ON_BrepTrim& trim0 = brep.m_T[bottome.m_ti[0]];
const ON_BrepTrim& trim1 = brep.m_T[bottome.m_ti[1]];
const ON_BrepLoop& loop0 = brep.m_L[trim0.m_li];
const ON_BrepLoop& loop1 = brep.m_L[trim1.m_li];
bool bBottomFaceRev = brep.m_F[(loop0.m_fi != face->m_face_index) ? loop0.m_fi : loop1.m_fi].m_bRev;
bool bSideFaceRev = ( trim0.m_bRev3d != trim1.m_bRev3d )
? bBottomFaceRev
: !bBottomFaceRev;
face->m_bRev = bSideFaceRev;
}
}
}
}
if ( !bOK )
{
for ( vi = brep.m_V.Count(); vi >= vcount0; vi-- )
{
brep.DeleteVertex(brep.m_V[vi]);
}
}
return bOK;
}
static
bool ON_BrepExtrudeHelper_MakeTopLoop(
ON_Brep& brep,
ON_BrepFace& top_face,
int bottom_loop_index,
const ON_3dVector path_vector,
const int* side_face_index // array of brep.m_L[bottom_loop_index].m_ti.Count() face indices
)
{
bool rc = true;
int lti, top_trim_index, i;
if ( bottom_loop_index < 0 || bottom_loop_index >= brep.m_L.Count() )
return false;
ON_BrepLoop::TYPE loop_type = brep.m_L[bottom_loop_index].m_type;
if ( loop_type != ON_BrepLoop::inner )
loop_type = ON_BrepLoop::outer;
ON_BrepLoop& top_loop = brep.NewLoop( loop_type, top_face );
const ON_BrepLoop& bottom_loop = brep.m_L[bottom_loop_index];
const int loop_trim_count = bottom_loop.m_ti.Count();
brep.m_T.Reserve( brep.m_T.Count() + loop_trim_count );
// Set top_vertex_index[lti] = index of vertex above
// vertex brep.m_V[brep.m_T[bottom_loop.m_ti[lti]].m_vi[0]].
// Set top_vertex_index[lti] = index of edge above
// edge of brep.m_T[bottom_loop.m_ti[lti]].
// This informtion is needed for singular and seam trims.
ON_SimpleArray<int> top_vertex_index(loop_trim_count);
ON_SimpleArray<int> top_edge_index(loop_trim_count);
ON_SimpleArray<bool> top_trim_bRev3d(loop_trim_count);
for ( lti = 0; lti < loop_trim_count; lti++ )
{
top_vertex_index.Append(-1);
top_edge_index.Append(-1);
top_trim_bRev3d.Append(false);
}
// some (often all of) of the "top" vertices are already on
// the side faces
for ( lti = 0; lti < loop_trim_count; lti++ )
{
if ( side_face_index[lti] >= 0 )
{
const ON_BrepFace& side_face = brep.m_F[side_face_index[lti]];
const ON_BrepLoop& side_loop = brep.m_L[side_face.m_li[0]];
const ON_BrepTrim& side_north_trim = brep.m_T[side_loop.m_ti[2]];
top_vertex_index[lti] = side_north_trim.m_vi[0];
top_vertex_index[(lti+1)%loop_trim_count] = side_north_trim.m_vi[1];
top_edge_index[lti] = side_north_trim.m_ei;
}
else
{
// fix for RR 20423
int lti_prev = (lti+loop_trim_count-1)%loop_trim_count;
int lti_next = (lti+1)%loop_trim_count;
if ( side_face_index[lti_prev] < 0
&& side_face_index[lti_next] < 0
&& top_vertex_index[lti] < 0
&& top_vertex_index[lti_next] < 0
)
{
int bottom_ti_prev = bottom_loop.m_ti[lti_prev];
int bottom_ti = bottom_loop.m_ti[lti];
int bottom_ti_next = bottom_loop.m_ti[lti_next];
if ( bottom_ti >= 0 && bottom_ti < brep.m_T.Count()
&& bottom_ti_prev >= 0 && bottom_ti_prev < brep.m_T.Count()
&& bottom_ti_next >= 0 && bottom_ti_next < brep.m_T.Count()
)
{
const ON_BrepTrim& bottom_trim_prev = brep.m_T[bottom_ti_prev];
const ON_BrepTrim& bottom_trim = brep.m_T[bottom_ti];
const ON_BrepTrim& bottom_trim_next = brep.m_T[bottom_ti_next];
if ( ON_BrepTrim::seam == bottom_trim_prev.m_type
&& ON_BrepTrim::singular == bottom_trim.m_type
&& ON_BrepTrim::seam == bottom_trim_next.m_type
&& bottom_trim.m_vi[0] == bottom_trim.m_vi[1]
)
{
int vi = bottom_trim.m_vi[0];
if ( vi >= 0 && vi < brep.m_V.Count() )
{
ON_BrepVertex& top_vertex = brep.NewVertex(brep.m_V[vi].point+path_vector,0.0);
top_vertex_index[lti] = top_vertex.m_vertex_index;
top_vertex_index[lti_next] = top_vertex_index[lti];
}
}
}
}
}
}
// Fill in the missing "top" vertices that
// are associated with singular and trim edges by looking
// at their neighbors.
{
bool bKeepChecking = true;
while( bKeepChecking )
{
// set back to true if we make a change. This handles the
// (very rare) cases of multiple adjacent singular trims.
bKeepChecking = false;
for ( lti = 0; lti < loop_trim_count; lti++ )
{
if ( top_vertex_index[lti] == -1 )
{
for ( i = lti+1; i < loop_trim_count; i++ )
{
if ( ON_BrepTrim::singular != brep.m_T[bottom_loop.m_ti[i-1]].m_type )
break;
if ( top_vertex_index[i] >= 0 )
{
top_vertex_index[lti] = top_vertex_index[i];
bKeepChecking = true;
break;
}
}
}
if ( top_vertex_index[lti] == -1 )
{
for ( i = lti-1; i >= 0; i-- )
{
if ( ON_BrepTrim::singular != brep.m_T[bottom_loop.m_ti[i+1]].m_type )
break;
if ( top_vertex_index[i] >= 0 )
{
top_vertex_index[lti] = top_vertex_index[i];
bKeepChecking = true;
break;
}
}
}
}
}
}
// Fill in missing edges of "seam" trims.
for ( lti = 0; lti < loop_trim_count; lti++ )
{
if ( -1 != top_edge_index[lti] )
continue;
int bottom_ti = bottom_loop.m_ti[lti];
if ( bottom_ti < 0 || bottom_ti >= brep.m_T.Count() )
continue;
const ON_BrepTrim& bottom_trim = brep.m_T[bottom_ti];
if ( ON_BrepTrim::seam != bottom_trim.m_type )
continue;
if ( bottom_trim.m_ei < 0 )
continue;
if ( bottom_trim.m_ei >= brep.m_E.Count() )
continue;
// duplicate bottom edge curve
const ON_BrepEdge& bottom_edge = brep.m_E[bottom_trim.m_ei];
ON_Curve* top_c3 = bottom_edge.DuplicateCurve();
if ( 0 == top_c3 )
continue;
// move new edge curve to top location
top_c3->Translate(path_vector);
ON_3dPoint P0 = top_c3->PointAtStart();
ON_3dPoint P1 = top_c3->PointAtEnd();
int top_c3i = brep.AddEdgeCurve(top_c3);
top_c3 = 0;
// get vertices at start/end of the new edge
int e_vi0 = top_vertex_index[lti];
int e_vi1 = top_vertex_index[(lti+1)%loop_trim_count];
if ( bottom_trim.m_bRev3d )
{
// put points in trim order
ON_3dPoint tmp_P = P0; P0 = P1; P1 = tmp_P;
}
if ( e_vi0 < 0 )
{
e_vi0 = brep.NewVertex(P0).m_vertex_index;
top_vertex_index[lti] = e_vi0;
}
if ( e_vi1 < 0 )
{
e_vi1 = brep.NewVertex(P1).m_vertex_index;
top_vertex_index[(lti+1)%loop_trim_count] = e_vi1;
}
if ( bottom_trim.m_bRev3d )
{
// put edge vertex indices in edge order
int tmp_i = e_vi0; e_vi0 = e_vi1; e_vi1 = tmp_i;
}
ON_BrepEdge& top_edge = brep.NewEdge(brep.m_V[e_vi0],brep.m_V[e_vi1],top_c3i);
top_edge.m_tolerance = bottom_edge.m_tolerance;
top_edge_index[lti] = top_edge.m_edge_index;
top_trim_bRev3d[lti] = bottom_trim.m_bRev3d?true:false;
// find seam mate and set it's
// top_edge_index[] to top_edge.m_edge_index.
int mate_lti;
for( mate_lti = lti+1; mate_lti < loop_trim_count; mate_lti++ )
{
if ( top_edge_index[mate_lti] != -1 )
continue;
int bottom_mate_ti = bottom_loop.m_ti[mate_lti];
if ( bottom_mate_ti < 0 || bottom_mate_ti >= brep.m_T.Count() )
continue;
const ON_BrepTrim& bottom_mate_trim = brep.m_T[bottom_mate_ti];
if ( bottom_mate_trim.m_type != ON_BrepTrim::seam )
continue;
if ( bottom_mate_trim.m_ei != bottom_trim.m_ei )
continue;
top_edge_index[mate_lti] = top_edge.m_edge_index;
top_trim_bRev3d[mate_lti] = bottom_mate_trim.m_bRev3d?true:false;
break;
}
}
for ( lti = 0; lti < loop_trim_count; lti++ )
{
const ON_BrepTrim& bottom_trim = brep.m_T[ bottom_loop.m_ti[lti] ];
ON_Curve* top_c2 = bottom_trim.DuplicateCurve();
int top_c2i = (0!=top_c2) ? brep.AddTrimCurve(top_c2) : bottom_trim.m_c2i;
top_trim_index = -1;
if ( bottom_trim.m_type == ON_BrepTrim::singular && top_vertex_index[lti] >= 0 )
{
top_trim_index = brep.NewSingularTrim(brep.m_V[top_vertex_index[lti]], top_loop, bottom_trim.m_iso, top_c2i ).m_trim_index;
}
else if ( bottom_trim.m_type != ON_BrepTrim::singular && top_edge_index[lti] >= 0 && top_edge_index[lti] < brep.m_E.Count() )
{
ON_BrepEdge& top_edge = brep.m_E[top_edge_index[lti]];
top_trim_index = brep.NewTrim( top_edge, top_trim_bRev3d[lti], top_loop, top_c2i ).m_trim_index;
}
else
{
ON_ERROR("ON_BrepExtrudeHelper_MakeTopLoop ran into capping trouble.");
rc = false;
break;
}
ON_BrepTrim& top_trim = brep.m_T[top_trim_index];
top_trim.m_pline = bottom_trim.m_pline;
top_trim.m_pbox = bottom_trim.m_pbox;
top_trim.m_iso = bottom_trim.m_iso;
top_trim.m_type = bottom_trim.m_type;
top_trim.m_tolerance[0] = bottom_trim.m_tolerance[0];
top_trim.m_tolerance[1] = bottom_trim.m_tolerance[1];
top_trim.m__legacy_2d_tol = bottom_trim.m__legacy_2d_tol;
top_trim.m__legacy_3d_tol = bottom_trim.m__legacy_2d_tol;
top_trim.m__legacy_flags = bottom_trim.m__legacy_flags;
}
if (rc)
{
top_loop.m_pbox = bottom_loop.m_pbox;
}
return rc;
}
bool ON_BrepConeLoop(
ON_Brep& brep,
int loop_index,
ON_3dPoint apex_point
)
{
if ( loop_index < 0 && loop_index >= brep.m_L.Count() )
return false;
int lti, ti, i, vid[4], eid[4], bRev3d[4];
// indices of new faces appended to the side_face_index[] array
// (1 face index for each trim, -1 is used for singular trims)
// count number of new objects so we can grow arrays
// efficiently and use refs to dynamic array elements.
const int loop_trim_count = brep.m_L[loop_index].m_ti.Count();
if ( loop_trim_count == 0 )
return false;
// save input trim and edge counts for use below
const int trim_count0 = brep.m_T.Count();
const int edge_count0 = brep.m_E.Count();
ON_BrepExtrudeHelper_ReserveSpace( brep, loop_trim_count, 0 );
int prev_face_index = -1;
int first_face_east_trim_index = -1;
ON_BrepVertex& apex_vertex = brep.NewVertex( apex_point, 0.0 );
for ( lti = 0; lti < loop_trim_count; lti++ )
{
ON_NurbsSurface* cone_srf = 0;
ti = brep.m_L[loop_index].m_ti[lti];
if ( ti < 0 || ti >= trim_count0 )
continue;
for ( i = 0; i < 4; i++ )
{
vid[i] = -1;
eid[i] = -1;
}
bRev3d[0] = false;
bRev3d[1] = false;
bRev3d[2] = false;
bRev3d[3] = false;
// get side surface for new face
// get side surface for new face
{
ON_BrepTrim& trim = brep.m_T[ti];
if ( trim.m_ei >= 0 && trim.m_ei < edge_count0 )
{
const ON_BrepEdge& base_edge = brep.m_E[trim.m_ei];
// connect new face to existing topology on trim
vid[0] = trim.m_vi[1];
vid[1] = trim.m_vi[0];
eid[0] = base_edge.m_edge_index;
bRev3d[0] = (trim.m_bRev3d?false:true);
cone_srf = ON_BrepExtrudeHelper_MakeConeSrf( apex_point, base_edge, bRev3d[0] );
}
}
if ( !cone_srf )
continue;
vid[2] = apex_vertex.m_vertex_index;
vid[3] = apex_vertex.m_vertex_index;
if ( prev_face_index >= 0 )
{
const ON_BrepTrim& prev_west_trim = brep.m_T[ brep.m_L[ brep.m_F[prev_face_index].m_li[0]].m_ti[3] ];
vid[2] = prev_west_trim.m_vi[0];
eid[1] = prev_west_trim.m_ei;
bRev3d[1] = (prev_west_trim.m_bRev3d?false:true);
}
if ( first_face_east_trim_index >= 0 && brep.m_T[first_face_east_trim_index].m_vi[0] == vid[0] )
{
const ON_BrepTrim& first_face_east_trim = brep.m_T[first_face_east_trim_index];
vid[3] = first_face_east_trim.m_vi[1];
eid[3] = first_face_east_trim.m_ei;
bRev3d[3] = (first_face_east_trim.m_bRev3d?false:true);
}
const ON_BrepFace* side_face = brep.NewFace(cone_srf,vid,eid,bRev3d);
if ( side_face )
{
prev_face_index = side_face->m_face_index;
if ( first_face_east_trim_index < 0 )
first_face_east_trim_index = brep.m_L[ side_face->m_li[0] ].m_ti[1];
}
}
return true;
}
int ON_BrepConeFace(
ON_Brep& brep,
int face_index,
ON_3dPoint apex_point
)
{
int rc = 0; // returns 1 for success with no cap, 2 for success with a cap
if ( face_index < 0 || face_index >= brep.m_F.Count() )
return false;
const int face_loop_count = brep.m_F[face_index].m_li.Count();
if ( face_loop_count < 1 )
return false;
if ( brep.m_F[face_index].m_li.Count() == 1 )
{
rc = ON_BrepConeLoop( brep, brep.m_F[face_index].m_li[0], apex_point );
}
else
{
int li, fli;
//const int trim_count0 = brep.m_T.Count();
const int loop_count0 = brep.m_L.Count();
//const int face_count0 = brep.m_F.Count();
// count number of new objects so we can grow arrays
// efficiently and use refs to dynamic array elements.
int new_side_trim_count = 0;
for ( fli = 0; fli < face_loop_count; fli++ )
{
li = brep.m_F[face_index].m_li[fli];
if ( li < 0 || li >= loop_count0 )
return false;
if ( !ON_BrepExtrudeHelper_CheckLoop( brep, li ) )
continue;
new_side_trim_count += brep.m_L[li].m_ti.Count();
}
if ( new_side_trim_count == 0 )
return false;
ON_BrepExtrudeHelper_ReserveSpace( brep, new_side_trim_count, 0 );
const ON_BrepFace& face = brep.m_F[face_index];
//ON_BrepVertex& apex_vertex =
brep.NewVertex( apex_point, 0.0 );
rc = true;
for ( fli = 0; fli < face_loop_count && rc; fli++ )
{
li = face.m_li[fli];
if ( !ON_BrepExtrudeHelper_CheckLoop( brep, li ) )
continue;
rc = ON_BrepConeLoop( brep, li, apex_point );
}
}
return rc;
}