DATAKIT API  V2025.1
Enumerations | Functions
sampleWriter Namespace Reference

Enumerations

enum  {
  Lump = 1, Volume = 2, Shell = 3, Vertex_A = 9,
  Vertex_B = 11, Vertex_C = 17, Vertex_D = 23, Vertex_E = 37,
  Vertex_F = 45, Vertex_G = 63, Vertex_H = 81, Edge_AB = 14,
  Edge_CA = 20, Edge_DC = 26, Edge_BD = 30, Edge_EA = 40,
  Edge_FB = 48, Edge_FE = 52, Edge_GD = 66, Edge_GF = 70,
  Edge_HC = 84, Edge_HG = 88, Edge_EH = 96, Coedge0_AB = 8,
  Coedge1_AB = 42, Coedge0_CA = 16, Coedge5_CA = 112, Coedge0_DC = 22,
  Coedge3_DC = 78, Coedge0_BD = 28, Coedge2_BD = 60, Coedge1_EA = 36,
  Coedge5_EA = 114, Coedge1_FB = 44, Coedge2_FB = 58, Coedge1_FE = 50,
  Coedge2_GD = 62, Coedge3_GD = 76, Coedge4_FE = 98, Coedge2_GF = 68,
  Coedge4_GF = 100, Coedge3_HC = 80, Coedge5_HC = 110, Coedge3_HG = 86,
  Coedge4_HG = 102, Coedge4_EH = 94, Coedge5_EH = 108, Loop0_ABCD = 7,
  Loop1_ABFE = 35, Loop2_FBDG = 57, Loop3_GDCH = 75, Loop4_EFGH = 93,
  Loop5_EHCA = 107, FaceABCD = 5, FaceABFE = 33, FaceFBDG = 55,
  FaceGDCH = 73, FaceEFGH = 91, FaceEHCA = 105
}
 

Functions

Dtk_BodyPtr CreateAxis ()
 
Dtk_AxisSystemPtr CreateAxisSystem ()
 
Dtk_BodyPtr CreateConstructionPlane ()
 
Dtk_BodyPtr CreateCube ()
 
Dtk_BodyPtr CreateCube_2 ()
 
Dtk_RenderInfosPtr CreateCubeRenderInfos ()
 
Dtk_BodyPtr CreateCurves ()
 
Dtk_BodyPtr CreateCurves_2 ()
 
Dtk_BodyPtr CreateCurvesStyle ()
 
Dtk_BodyPtr CreateCyl (double radius, double height)
 
Dtk_BodyPtr CreateCylinder ()
 
Dtk_BodyPtr CreateEsquisse2D ()
 
Dtk_BodyPtr CreateEsquisse3D ()
 
Dtk_FdtPtr CreateFdtDatum ()
 Create Simple Datum. More...
 
Dtk_FdtPtr CreateFdtDimAssy ()
 PMI in Assembly : a dimension between faces of different instances. More...
 
Dtk_BodyPtr CreateInfinitePlane ()
 
Dtk_MeshPtr CreateMeshCube ()
 Mesh Cube sample. More...
 
void CreateMeshCubeFaces (Dtk_mesh *outCubeMesh)
 Create Mesh Faces For Cube. More...
 
void CreateMeshCubeGeometry (Dtk_tab< Dtk_pnt > &vertices, Dtk_tab< Dtk_dir > &normals, Dtk_tab< Dtk_Float32 > &uCoords, Dtk_tab< Dtk_Float32 > &vCoords)
 Create Mesh Geometry For Cube. More...
 
void CreateMeshCubeidGeometry (Dtk_tab< Dtk_pnt > &vertices, Dtk_tab< Dtk_dir > &normals, Dtk_tab< Dtk_Float32 > &uCoords, Dtk_tab< Dtk_Float32 > &vCoords, Dtk_pair< Dtk_pnt, Dtk_pnt > inPoints)
 Create Mesh Geometry For Cuboid. More...
 
Dtk_MeshPtr CreateMeshCubeVertexColor ()
 
Dtk_MeshPtr CreateMeshCuboid (const Dtk_pnt &inFirstPoint, const Dtk_pnt &inSecondPoint)
 
Dtk_MeshPtr CreateMeshCylinder (int nbpoints)
 Mesh Cylinder sample. More...
 
Dtk_MeshPtr CreateMeshPoints ()
 Points mesh sample. More...
 
Dtk_MeshPtr CreateMeshWire ()
 Wire mesh sample. More...
 
Dtk_ModelDisplayPtr CreateModelDisplayActivated ()
 
Dtk_ModelDisplayPtr CreateModelDisplayDesactivated ()
 
Dtk_ModelDisplayPtr CreateModelDisplayWithSection ()
 
Dtk_BodyPtr CreateOpenShell ()
 
void CreateOpenShell (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
Dtk_BodyPtr CreateOpenShell_2 ()
 
void CreateOpenShell_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
Dtk_BodyPtr CreatePoint ()
 
Dtk_MeshPtr CreateTexturedMeshCube (const Dtk_string &inImageDirectory)
 Textured Mesh Cube sample. More...
 
void CreateTopoCoEdge (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoCoEdge_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoEdge (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoEdge_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoFace (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoFace_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoLoop (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoLoop_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoLump (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoLump_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoShell (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoShell_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoVertex (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoVertex_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoVolume (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
void CreateTopoVolume_2 (std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
 
Dtk_ModelDisplayPtr CreateView ()
 
void FillFacesColors (Dtk_MeshPtr &inoutCubeMesh)
 Filling mesh faces with colors. More...
 
void FillInfos (Dtk_InfoPtr &inf, Dtk_ID id, const Dtk_RGB &color)
 
Dtk_CurvePtr MakeArc2D (const Dtk_pnt &P0, double radius, double from, double to)
 
Dtk_CoedgePtr MakeCoedge (Dtk_BodyPtr &body, const Dtk_EdgePtr edge, Dtk_bool sensedgeVScoedge, const Dtk_CurvePtr &curve2d)
 
Dtk_SurfacePtr MakeCyl (const Dtk_pnt &O, double radius, double height)
 
Dtk_EdgePtr MakeEdge (Dtk_BodyPtr &body, const Dtk_VertexPtr &vstart, const Dtk_VertexPtr &vend, const Dtk_CurvePtr &curve3d, Dtk_ID id)
 
Dtk_FacePtr MakeOuterFace (Dtk_BodyPtr &body, const Dtk_SurfacePtr &surf, const Dtk_CoedgePtr &c0, const Dtk_CoedgePtr &c1, const Dtk_CoedgePtr &c2, const Dtk_CoedgePtr &c3)
 
Dtk_SurfacePtr MakePlane (const Dtk_pnt &O, const Dtk_pnt &N, double trim)
 
Dtk_CurvePtr MakeSegment (const Dtk_pnt &P0, const Dtk_pnt &P1)
 
Dtk_CurvePtr MakeSegment2D (double xmin, double ymin, double xmax, double ymax)
 
Dtk_VertexPtr MakeVertex (Dtk_BodyPtr &body, const Dtk_pnt &P)
 
void SetTopoFaceID (const Dtk_FacePtr &face, const Dtk_ID id)
 

Enumeration Type Documentation

◆ anonymous enum

anonymous enum
Enumerator
Lump 
Volume 
Shell 
Vertex_A 
Vertex_B 
Vertex_C 
Vertex_D 
Vertex_E 
Vertex_F 
Vertex_G 
Vertex_H 
Edge_AB 
Edge_CA 
Edge_DC 
Edge_BD 
Edge_EA 
Edge_FB 
Edge_FE 
Edge_GD 
Edge_GF 
Edge_HC 
Edge_HG 
Edge_EH 
Coedge0_AB 
Coedge1_AB 
Coedge0_CA 
Coedge5_CA 
Coedge0_DC 
Coedge3_DC 
Coedge0_BD 
Coedge2_BD 
Coedge1_EA 
Coedge5_EA 
Coedge1_FB 
Coedge2_FB 
Coedge1_FE 
Coedge2_GD 
Coedge3_GD 
Coedge4_FE 
Coedge2_GF 
Coedge4_GF 
Coedge3_HC 
Coedge5_HC 
Coedge3_HG 
Coedge4_HG 
Coedge4_EH 
Coedge5_EH 
Loop0_ABCD 
Loop1_ABFE 
Loop2_FBDG 
Loop3_GDCH 
Loop4_EFGH 
Loop5_EHCA 
FaceABCD 
FaceABFE 
FaceFBDG 
FaceGDCH 
FaceEFGH 
FaceEHCA 
15  {
16  Lump = 1,
17  Volume = 2,
18  Shell = 3,
19  Vertex_A = 9,
20  Vertex_B = 11,
21  Vertex_C = 17,
22  Vertex_D = 23,
23  Vertex_E = 37,
24  Vertex_F = 45,
25  Vertex_G = 63,
26  Vertex_H = 81,
27  Edge_AB = 14,
28  Edge_CA = 20,
29  Edge_DC = 26,
30  Edge_BD = 30,
31  Edge_EA = 40,
32  Edge_FB = 48,
33  Edge_FE = 52,
34  Edge_GD = 66,
35  Edge_GF = 70,
36  Edge_HC = 84,
37  Edge_HG = 88,
38  Edge_EH = 96,
39  Coedge0_AB = 8,
40  Coedge1_AB = 42,
41  Coedge0_CA = 16,
42  Coedge5_CA = 112,
43  Coedge0_DC = 22,
44  Coedge3_DC = 78,
45  Coedge0_BD = 28,
46  Coedge2_BD = 60,
47  Coedge1_EA = 36,
48  Coedge5_EA = 114,
49  Coedge1_FB = 44,
50  Coedge2_FB = 58,
51  Coedge1_FE = 50,
52  Coedge2_GD = 62,
53  Coedge3_GD = 76,
54  Coedge4_FE = 98,
55  Coedge2_GF = 68,
56  Coedge4_GF = 100,
57  Coedge3_HC = 80,
58  Coedge5_HC = 110,
59  Coedge3_HG = 86,
60  Coedge4_HG = 102,
61  Coedge4_EH = 94,
62  Coedge5_EH = 108,
63  Loop0_ABCD = 7,
64  Loop1_ABFE = 35,
65  Loop2_FBDG = 57,
66  Loop3_GDCH = 75,
67  Loop4_EFGH = 93,
68  Loop5_EHCA = 107,
69  FaceABCD = 5,
70  FaceABFE = 33,
71  FaceFBDG = 55,
72  FaceGDCH = 73,
73  FaceEFGH = 91,
74  FaceEHCA = 105,
75  };

Function Documentation

◆ CreateAxis()

Dtk_BodyPtr sampleWriter::CreateAxis ( )
1493  {
1494  Dtk_BodyPtr mybody = Dtk_Body::Create();
1495  Dtk_ShellPtr shell = Dtk_Shell::Create( mybody );
1496  Dtk_tab<Dtk_CurvePtr> CurveArray;
1497 
1498  mybody->info() = Dtk_Info::create();
1499  mybody->get_info()->SetInfiniteGeometryFlag( DTK_TRUE );
1500  mybody->get_info()->SetRefEntityFlag( DTK_TRUE );
1501 
1502 
1503  Dtk_LinePtr lineptr = Dtk_Line::Create( Dtk_pnt( -41, -42, -50 ), Dtk_pnt( -51, -52, -50 ) );
1504  lineptr->info() = Dtk_Info::create();
1505  lineptr->info()->SetColor( Dtk_RGB( 0, 255, 25, 255 ) );
1506  lineptr->info()->SetName( L"myaxe" );
1507 
1508 
1509  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of myaxe", L"Value of myaxe" );
1510  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
1511  ArrayMetadataEntity.push_back( metadata );
1512  lineptr->info()->SetMetaData( ArrayMetadataEntity );
1513 
1514  CurveArray.push_back( Dtk_CurvePtr::DtkDynamicCast( lineptr ) );
1515 
1516  shell->AddWire( CurveArray );
1517  mybody->AddWireShell( shell );
1518 
1519  return mybody;
1520  }

◆ CreateAxisSystem()

Dtk_AxisSystemPtr sampleWriter::CreateAxisSystem ( )
1466  {
1467  Dtk_AxisSystemPtr mycsystem = Dtk_AxisSystem::create();
1468  Dtk_transfo dtk_transfo;
1469  dtk_transfo.setXdir( 0.0, 0.0, 1.0 );
1470  dtk_transfo.setYdir( -1.0, 0.0, 0.0 );
1471  dtk_transfo.setZdir( 0.0, -1.0, 0.0 );
1472  dtk_transfo.setOrigin( Dtk_pnt( -41, -42, -50 ) );
1473  mycsystem->SetMatrix( dtk_transfo );
1474  mycsystem->info() = Dtk_Info::create();
1475  mycsystem->info()->SetName( L"mycsystem" );
1476  mycsystem->info()->SetColor( Dtk_RGB( 255, 0, 0, 255 ) );
1477  mycsystem->info()->SetLayer( 123 );
1478 
1479 
1480  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mycsystem", L"Value of mycsystem" );
1481  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
1482  ArrayMetadataEntity.push_back( metadata );
1483  mycsystem->info()->SetMetaData( ArrayMetadataEntity );
1484 
1485  //Uncomment to put the AxisSystem as Blanked
1486  //mycsystem->info()->SetBlankedStatus(DTK_TRUE);
1487 
1488  return mycsystem;
1489  }

◆ CreateConstructionPlane()

Dtk_BodyPtr sampleWriter::CreateConstructionPlane ( )
1186  {
1187  Dtk_BodyPtr body = Dtk_Body::Create();
1188  Dtk_PlaneSurfacePtr plan = Dtk_PlaneSurface::Create(Dtk_pnt(0., 50., 0.), Dtk_dir(0., 1., 0.), Dtk_dir(1., 0., 0.));
1189  Dtk_FacePtr face = Dtk_Face::Create(body);
1190  face->SetGeom(Dtk_SurfacePtr::DtkDynamicCast(plan));
1191  Dtk_ShellPtr shell = Dtk_Shell::Create(body);
1192  shell->AddFace(face, DTK_TRUE);
1193  body->AddOpenShell(shell);
1194  body->info() = Dtk_Info::create();
1195  body->info()->SetName("Plane Y=50");
1196  return body;
1197  }

◆ CreateCube()

Dtk_BodyPtr sampleWriter::CreateCube ( )
1250  {
1251  std::map<Dtk_ID, Dtk_EntityPtr> array_topo;
1252 
1253  Dtk_BodyPtr body = Dtk_Body::Create(); // create the Body
1254  body->info() = Dtk_Info::create();
1255  body->info()->SetName( L"Body" );
1256 
1257  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of Body", L"Value of Body" );
1258  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
1259  ArrayMetadataEntity.push_back( metadata );
1260  body->info()->SetMetaData( ArrayMetadataEntity );
1261 
1262  CreateTopoVertex( array_topo, body ); //create all Vertex
1263  CreateTopoEdge( array_topo, body ); //create all Edge
1264  CreateTopoCoEdge( array_topo, body );//create all Coedge
1265  CreateTopoLoop( array_topo, body );//create all Loop
1266  CreateTopoFace( array_topo, body );//create all Face
1267  CreateTopoShell( array_topo, body );//create all Shell
1268  CreateTopoVolume( array_topo, body );//create all Volume
1269  CreateTopoLump( array_topo, body );//create all Lump
1270 
1271  body->AddLump( Dtk_LumpPtr::DtkDynamicCast( array_topo[ Lump ] ) ); // add the Lump into the body.
1272 
1273  return body;
1274  }

◆ CreateCube_2()

Dtk_BodyPtr sampleWriter::CreateCube_2 ( )
1093  {
1094  std::map<Dtk_ID, Dtk_EntityPtr> array_topo;
1095 
1096  Dtk_BodyPtr body = Dtk_Body::Create(); // create the Body
1097 
1098  CreateTopoVertex_2(array_topo, body); //create all Vertex
1099  CreateTopoEdge_2(array_topo, body); //create all Edge
1100  CreateTopoCoEdge_2(array_topo, body);//create all Coedge
1101  CreateTopoLoop_2(array_topo, body);//create all Loop
1102  CreateTopoFace_2(array_topo, body);//create all Face
1103  CreateTopoShell_2(array_topo, body);//create all Shell
1104  CreateTopoVolume_2(array_topo, body);//create all Volume
1105  CreateTopoLump_2(array_topo, body);//create all Lump
1106 
1107  body->AddLump(Dtk_LumpPtr::DtkDynamicCast(array_topo[1])); // add the Lump into the body.
1108 
1109  // V78 : val prop sur Body : IGNORED
1110  Dtk_InfoPtr& body_info = body->info();
1111  if (body_info.IsNULL()) body_info = Dtk_Info::create();
1112  Dtk_Val valprop_area("1234 mm2");
1113  body_info->AddAttribute("geometric validation property : : surface area measure", valprop_area);
1114  Dtk_Val valprop_volume("5678 mm3");
1115  body_info->AddAttribute("geometric validation property : : volume measure", valprop_volume);
1116  Dtk_Val valprop_CG(Dtk_pnt(12., 34., 56.));
1117  body_info->AddAttribute("geometric validation property : : centre point", valprop_CG);
1118 
1119  return body;
1120  }

◆ CreateCubeRenderInfos()

Dtk_RenderInfosPtr sampleWriter::CreateCubeRenderInfos ( )
499  {
500  //Variables
501  Dtk_RGB ambiant;
502  Dtk_RGB diffuse;
503  Dtk_RGB specular;
504  Dtk_LightMapPtr lightMap;
505  Dtk_TextureInfosPtr texture;
506  Dtk_string fileName;
507 
508  //Creating lighting
509  ambiant.SetRGBA( 255, 255, 255 );
510  diffuse.SetRGBA( 255, 255, 255 );
511  specular.SetRGBA( 255, 255, 255 );
512  lightMap = Dtk_LightMap::Create( ambiant, diffuse, specular );
513 
514  //Creating texture using cubical mapping
515  texture = Dtk_TextureInfos::Create( Dtk_TextureInfos::CubicalMapping );
516  //Setting image to the texture
517  fileName = "..\\InputImages\\sample.bmp";
518  texture->SetImagePath( fileName );
519  //Scaling the texture
520  texture->SetScale( 2, 2 );
521 
522  //Finally creating render informations
523  Dtk_RenderInfosPtr renderInfo = Dtk_RenderInfos::Create( "Rendering", lightMap, texture );
524 
525  return renderInfo;
526  }

◆ CreateCurves()

Dtk_BodyPtr sampleWriter::CreateCurves ( )
1293  {
1294  Dtk_tab<Dtk_CurvePtr> mycurves;
1295  Dtk_BodyPtr mybody;
1296  mybody = Dtk_Body::Create();
1297  Dtk_ShellPtr myshell;
1298  myshell = Dtk_Shell::Create( mybody );
1299 
1300  Dtk_EllipsePtr myellipse;
1301 
1302  //add circle curve
1303  myellipse = Dtk_Ellipse::Create( Dtk_pnt( 0.0, 0.0, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 10.0 );
1304  Dtk_CurvePtr mycurve;
1305  mycurve = Dtk_CurvePtr::DtkDynamicCast( myellipse );
1306  mycurve->info() = Dtk_Info::create();
1307  mycurve->info()->SetColor( Dtk_RGB( 255, 0, 255 ) );
1308  mycurve->info()->SetName( "mycircle" );
1309  mycurves.push_back( mycurve );
1310 
1311 
1312  //add ellipse curve
1313  myellipse = Dtk_Ellipse::Create( Dtk_pnt( 0.0, 0.0, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 10.0, 5.0 );
1314  mycurve = Dtk_CurvePtr::DtkDynamicCast( myellipse );
1315  mycurve->info() = Dtk_Info::create();
1316  mycurve->info()->SetColor( Dtk_RGB( 255, 255, 0 ) );
1317  mycurve->info()->SetName( "myellipse" );
1318  mycurves.push_back( mycurve );
1319 
1320 
1321  //add line curve
1322  Dtk_LinePtr myline;
1323  myline = Dtk_Line::Create( Dtk_pnt( -5.0, 0.0, 0.0 ), Dtk_pnt( 5.0, 0.0, 0.0 ) );
1324  mycurve = Dtk_CurvePtr::DtkDynamicCast( myline );
1325  mycurve->info() = Dtk_Info::create();
1326  mycurve->info()->SetColor( Dtk_RGB( 0, 0, 255 ) );
1327  mycurve->info()->SetName( "myline" );
1328  mycurves.push_back( mycurve );
1329 
1330 
1331  //add nurbs curve
1332  //nurbs with 4 Control Points
1333  //respect num_points = Knots.size() - Degree - 1;
1334  Dtk_tab<Dtk_pnt> ControlPoints;
1335  Dtk_tab<Dtk_Double64> Knots;
1336  Dtk_Int32 Degree = 3;
1337  ControlPoints.resize(4);
1338  ControlPoints[ 0 ] = Dtk_pnt(-5.0 , 0.0, 0.0);
1339  ControlPoints[ 1 ] = Dtk_pnt( -2.0, 5.0, 0. );
1340  ControlPoints[ 2 ] = Dtk_pnt( 2.0, -5.0, 0. );
1341  ControlPoints[ 3 ] = Dtk_pnt( 5.0, 0.0, 0. );
1342  Knots.resize(8);
1343  Knots[ 0 ] = Knots[ 1 ] = Knots[ 2 ] = Knots[ 3 ] = 0.0;
1344  Knots[ 4 ] = Knots[ 5 ] = Knots[ 6 ] = Knots[ 7 ] = 1.0;
1345 
1346  Dtk_NurbsCurvePtr cnurbs = Dtk_NurbsCurve::Create(Degree, Knots, ControlPoints);
1347  mycurve = Dtk_CurvePtr::DtkDynamicCast(cnurbs);
1348  mycurve->info() = Dtk_Info::create();
1349  mycurve->info()->SetColor(Dtk_RGB(0, 255, 0));
1350  mycurve->info()->SetName("mynurbs");
1351  mycurves.push_back(mycurve);
1352 
1353 
1354 
1355  myshell->AddWire( mycurves );
1356  mybody->AddWireShell( myshell );
1357 
1358 
1359  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mycurve", L"Value of mycurve" );
1360  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
1361  ArrayMetadataEntity.push_back( metadata );
1362 
1363  mybody->info() = Dtk_Info::create();
1364  mybody->info()->SetMetaData( ArrayMetadataEntity );
1365 
1366  return mybody;
1367  }

◆ CreateCurves_2()

Dtk_BodyPtr sampleWriter::CreateCurves_2 ( )
1139  {
1140  Dtk_tab<Dtk_CurvePtr> mycurves;
1141  Dtk_BodyPtr mysbody;
1142  mysbody = Dtk_Body::Create();
1143 
1144  Dtk_ShellPtr myshell;
1145  myshell = Dtk_Shell::Create(mysbody);
1146 
1147  Dtk_EllipsePtr myellipse;
1148  myellipse = Dtk_Ellipse::Create(Dtk_pnt(0.0, 0.0, 0.0), Dtk_dir(0.0, 0.0, 1.0), Dtk_dir(1.0, 0.0, 0.0), 10.0);
1149 
1150  Dtk_CurvePtr mycurve;
1151  mycurve = Dtk_CurvePtr::DtkDynamicCast(myellipse);
1152 
1153  mycurve->info() = Dtk_Info::create();
1154  mycurve->info()->SetColor(Dtk_RGB(255, 0, 255));
1155  mycurve->info()->SetName("mycircle");
1156 
1157  mycurves.push_back(mycurve);
1158 
1159  Dtk_LinePtr myline;
1160  myline = Dtk_Line::Create(Dtk_pnt(-5.0, 0.0, 0.0), Dtk_pnt(5.0, 0.0, 0.0));
1161  mycurve = Dtk_CurvePtr::DtkDynamicCast(myline);
1162 
1163  mycurve->info() = Dtk_Info::create();
1164  mycurve->info()->SetColor(Dtk_RGB(0, 0, 255));
1165  mycurve->info()->SetName("myline");
1166 
1167  mycurves.push_back(mycurve);
1168 
1169  myshell->AddWire(mycurves);
1170  mysbody->AddWireShell(myshell);
1171 
1172  // Val Prop on Body : not yet supported
1173  Dtk_InfoPtr& body_info = mysbody->info();
1174  if (body_info.IsNULL()) body_info = Dtk_Info::create();
1175  Dtk_Val valprop_curve_length("1234 mm");
1176  body_info->AddAttribute("geometric validation property : : curve length measure", valprop_curve_length);
1177 
1178  return mysbody;
1179  }

◆ CreateCurvesStyle()

Dtk_BodyPtr sampleWriter::CreateCurvesStyle ( )
1371  {
1372  Dtk_tab<Dtk_CurvePtr> mycurves;
1373  Dtk_BodyPtr mybody;
1374  mybody = Dtk_Body::Create();
1375  Dtk_ShellPtr myshell;
1376  myshell = Dtk_Shell::Create(mybody);
1377 
1378  Dtk_EllipsePtr ellipsethick = Dtk_Ellipse::Create(Dtk_pnt(0.0, 0.0, 5.0), Dtk_dir(0.0, 0.0, 1.0), Dtk_dir(1.0, 0.0, 0.0), 10.0);
1379  ellipsethick->info() = Dtk_Info::create();
1380  ellipsethick->info()->SetColor(Dtk_RGB(255, 0, 0));
1381  ellipsethick->info()->SetCurveThickNessInMM(4);
1382  mycurves.push_back(Dtk_CurvePtr::DtkDynamicCast(ellipsethick));
1383 
1384 
1385  Dtk_EllipsePtr ellipsedash = Dtk_Ellipse::Create(Dtk_pnt(0.0, 0.0, 6.0), Dtk_dir(0.0, 0.0, 1.0), Dtk_dir(1.0, 0.0, 0.0), 10.0);
1386  ellipsedash->info() = Dtk_Info::create();
1387  ellipsedash->info()->SetColor(Dtk_RGB(0, 0, 255));
1388  ellipsedash->info()->SetCurveLineType(DTK_DASHED);
1389  mycurves.push_back(Dtk_CurvePtr::DtkDynamicCast(ellipsedash));
1390 
1391  Dtk_EllipsePtr ellipsedotted = Dtk_Ellipse::Create(Dtk_pnt(0.0, 0.0, 7.0), Dtk_dir(0.0, 0.0, 1.0), Dtk_dir(1.0, 0.0, 0.0), 10.0);
1392  ellipsedotted->info() = Dtk_Info::create();
1393  ellipsedotted->info()->SetColor(Dtk_RGB(255, 0, 255));
1394  ellipsedotted->info()->SetCurveLineType(DTK_DOTTED);
1395  ellipsedotted->info()->SetCurveThickNessInMM(2);
1396  mycurves.push_back(Dtk_CurvePtr::DtkDynamicCast(ellipsedotted));
1397 
1398  myshell->AddWire(mycurves);
1399  mybody->AddWireShell(myshell);
1400  mybody->info() = Dtk_Info::create();
1401 
1402  return mybody;
1403  }

◆ CreateCyl()

Dtk_BodyPtr sampleWriter::CreateCyl ( double  radius,
double  height 
)
1792  {
1793  Dtk_BodyPtr body = Dtk_Body::Create();
1794  Dtk_LumpPtr lump = Dtk_Lump::Create(body);
1795  Dtk_VolumePtr volume = Dtk_Volume::Create(body);
1796  Dtk_ShellPtr shell = Dtk_Shell::Create(body);
1797  body->AddLump(lump);
1798  lump->AddVolume(volume);
1799  volume->AddOuterShell(shell);
1800 
1801  Dtk_pnt P[4];
1802  P[0] = Dtk_pnt(radius, 0, 0);
1803  P[1] = Dtk_pnt(radius, 0, height);
1804  P[2] = Dtk_pnt(-radius, 0, height);
1805  P[3] = Dtk_pnt(-radius, 0, 0);
1806  Dtk_VertexPtr v[4];
1807  Dtk_Size_t i;
1808  for (i = 0; i < 4; i++)
1809  v[i] = MakeVertex(body, P[i]);
1810  Dtk_EdgePtr e[6];
1811  e[0] = MakeEdge(body, v[0], v[1], MakeSegment(P[0], P[1]),1);
1812  e[1] = MakeEdge(body, v[2], v[3], MakeSegment(P[2], P[3]),2);
1813  e[2] = MakeEdge(body, v[3], v[0], MakeArc2D(Dtk_pnt(), radius, -DTK_PI, 0),3);
1814  e[3] = MakeEdge(body, v[0], v[3], MakeArc2D(Dtk_pnt(), radius, 0, DTK_PI),4);
1815  e[4] = MakeEdge(body, v[2], v[1], MakeArc2D(Dtk_pnt(0, 0, height), radius, -DTK_PI, 0),5);
1816  e[5] = MakeEdge(body, v[1], v[2], MakeArc2D(Dtk_pnt(0, 0, height), radius, 0, DTK_PI),6);
1817 
1818  Dtk_FacePtr half1 = MakeOuterFace(body, MakeCyl(Dtk_pnt(), radius, height),
1819  MakeCoedge(body, e[0], DTK_TRUE, MakeSegment2D(0, 0, 0, height)),
1820  MakeCoedge(body, e[4], DTK_FALSE, MakeSegment2D(0, height, -DTK_PI, height)),
1821  MakeCoedge(body, e[1], DTK_TRUE, MakeSegment2D(-DTK_PI, height, -DTK_PI, 0)),
1822  MakeCoedge(body, e[2], DTK_TRUE, MakeSegment2D(-DTK_PI, 0, 0, 0))
1823  );
1824  shell->AddFace(half1, DTK_TRUE);
1825  FillInfos(half1->info(), 1, Dtk_RGB());
1826 
1827  Dtk_FacePtr half2 = MakeOuterFace(body, MakeCyl(Dtk_pnt(), radius, height),
1828  MakeCoedge(body, e[3], DTK_TRUE, MakeSegment2D(0, 0, DTK_PI, 0)),
1829  MakeCoedge(body, e[1], DTK_FALSE, MakeSegment2D(DTK_PI, 0, DTK_PI, height)),
1830  MakeCoedge(body, e[5], DTK_FALSE, MakeSegment2D(DTK_PI, height, 0, height)),
1831  MakeCoedge(body, e[0], DTK_FALSE, MakeSegment2D(0, height, 0, 0))
1832  );
1833  shell->AddFace(half2, DTK_TRUE);
1834  FillInfos(half2->info(), 2, Dtk_RGB());
1835 
1836  Dtk_FacePtr plandown = MakeOuterFace(body, MakePlane(Dtk_pnt(), Dtk_dir(0, 0, -1), radius),
1837  MakeCoedge(body, e[2], DTK_FALSE, MakeArc2D(Dtk_pnt(), radius, 0, DTK_PI)),
1838  MakeCoedge(body, e[3], DTK_FALSE, MakeArc2D(Dtk_pnt(), radius, DTK_PI, 2 * DTK_PI)),
1839  NULL, NULL
1840  );
1841  shell->AddFace(plandown, DTK_TRUE);
1842  FillInfos(plandown->info(), 3, Dtk_RGB());
1843 
1844  Dtk_FacePtr planup = MakeOuterFace(body, MakePlane(Dtk_pnt(0, 0, height), Dtk_dir(0, 0, 1), radius),
1845  MakeCoedge(body, e[4], DTK_TRUE, MakeArc2D(Dtk_pnt(), radius, -DTK_PI, 0)),
1846  MakeCoedge(body, e[5], DTK_TRUE, MakeArc2D(Dtk_pnt(), radius, 0, DTK_PI)),
1847  NULL, NULL
1848  );
1849  shell->AddFace(planup, DTK_TRUE);
1850  FillInfos(planup->info(), 4, Dtk_RGB(0, 255, 0));
1851  body->info() = Dtk_Info::create();
1852 
1853  return body;
1854  }

◆ CreateCylinder()

Dtk_BodyPtr sampleWriter::CreateCylinder ( )
1212  {
1213  Dtk_BodyPtr mysbody;
1214  mysbody = Dtk_Body::Create();
1215 
1216  // Curves of edges
1217  Dtk_PointPtr P1 = Dtk_Point::Create(50., 0., 100.);
1218  Dtk_PointPtr P2 = Dtk_Point::Create(50., 0., 0.);
1219  Dtk_pnt cent1(0., 0., 100.);
1220  Dtk_EllipsePtr circ1 = Dtk_Ellipse::Create(cent1, Dtk_dir(0., 0., 1.), Dtk_dir(1., 0., 0.), 50.);
1221  Dtk_pnt cent2(0., 0., 0.);
1222  Dtk_EllipsePtr circ2 = Dtk_Ellipse::Create(cent2, Dtk_dir(0., 0., 1.), Dtk_dir(1., 0., 0.), 50.);
1223  Dtk_LinePtr seam = Dtk_Line::Create(Dtk_pnt(50., 0., 0.), Dtk_pnt(50., 0., 100.));
1224  // Surfaces of faces
1225  // Notice : for tessellation, it is required to record the UV trim in surfaces
1226  double trim[4];
1227  Dtk_PlaneSurfacePtr plan1 = Dtk_PlaneSurface::Create(cent1, Dtk_dir(0., 0., 1.), Dtk_dir(1., 0., 0.));
1228  trim[0] = -100.; trim[1] = 100.; trim[2] = -100.; trim[3] = 100.;
1229  plan1->SetTrimUVBox(trim);
1230  Dtk_PlaneSurfacePtr plan2 = Dtk_PlaneSurface::Create(cent2, Dtk_dir(0., 0., 1.), Dtk_dir(1., 0., 0.));
1231  plan2->SetTrimUVBox(trim);
1232  Dtk_CylindricalSurfacePtr cylsurf = Dtk_CylindricalSurface::Create(cent2, Dtk_dir(0., 0., 1.), Dtk_dir(1., 0., 0.), 50);
1233  trim[0] = 0.; trim[1] = 2.*DTK_PI;
1234  cylsurf->SetTrimUVBox(trim);
1235 
1236  // Topology
1237  // Vertices
1238  Dtk_VertexPtr V1 = Dtk_Vertex::Create(mysbody);
1239  V1->SetGeom(P1);
1240  Dtk_VertexPtr V2 = Dtk_Vertex::Create(mysbody);
1241  V2->SetGeom(P2);
1242  // Edges
1243  Dtk_EdgePtr E0 = Dtk_Edge::Create(mysbody);
1244  E0->SetGeom(Dtk_CurvePtr::DtkDynamicCast(seam));
1245  E0->SetStartVertex(V1);
1246  E0->SetEndVertex(V2);
1247  Dtk_EdgePtr E1 = Dtk_Edge::Create(mysbody);
1248  E1->SetGeom(Dtk_CurvePtr::DtkDynamicCast(circ1));
1249  E1->SetStartVertex(V1);
1250  E1->SetEndVertex(V1);
1251  Dtk_EdgePtr E2 = Dtk_Edge::Create(mysbody);
1252  E2->SetGeom(Dtk_CurvePtr::DtkDynamicCast(circ2));
1253  E2->SetStartVertex(V2);
1254  E2->SetEndVertex(V2);
1255 
1256  // Faces
1257  Dtk_FacePtr F0 = Dtk_Face::Create(mysbody);
1258  F0->SetGeom(Dtk_SurfacePtr::DtkDynamicCast(cylsurf));
1259  SetTopoFaceID(F0, 10);
1260  Dtk_FacePtr F1 = Dtk_Face::Create(mysbody);
1261  F1->SetGeom(Dtk_SurfacePtr::DtkDynamicCast(plan1));
1262  SetTopoFaceID(F1, 20);
1263  // test for face color different from body color
1264  F1->info()->SetColor(Dtk_RGB(255, 0, 0)); // info created by SetTopoFaceID
1265  Dtk_FacePtr F2 = Dtk_Face::Create(mysbody);
1266  F2->SetGeom(Dtk_SurfacePtr::DtkDynamicCast(plan2));
1267  SetTopoFaceID(F2, 30);
1268  // Loops + coedges
1269  Dtk_LoopPtr L0 = Dtk_Loop::Create(mysbody);
1270  Dtk_CoedgePtr C01 = Dtk_Coedge::Create(mysbody);
1271  C01->SetEdge(E1);
1272  L0->AddCoedge(C01, DTK_FALSE);
1273  Dtk_CoedgePtr C02 = Dtk_Coedge::Create(mysbody);
1274  C02->SetEdge(E0);
1275  L0->AddCoedge(C02, DTK_FALSE);
1276  Dtk_CoedgePtr C03 = Dtk_Coedge::Create(mysbody);
1277  C03->SetEdge(E2);
1278  L0->AddCoedge(C03, DTK_TRUE);
1279  Dtk_CoedgePtr C04 = Dtk_Coedge::Create(mysbody);
1280  C04->SetEdge(E0);
1281  L0->AddCoedge(C04, DTK_TRUE);
1282  F0->AddOuterLoop(L0);
1283 
1284  Dtk_LoopPtr L1 = Dtk_Loop::Create(mysbody);
1285  Dtk_CoedgePtr C1 = Dtk_Coedge::Create(mysbody);
1286  C1->SetEdge(E1);
1287  L1->AddCoedge(C1, DTK_TRUE);
1288  F1->AddOuterLoop(L1);
1289 
1290  Dtk_LoopPtr L2 = Dtk_Loop::Create(mysbody);
1291  Dtk_CoedgePtr C2 = Dtk_Coedge::Create(mysbody);
1292  C2->SetEdge(E2);
1293  L2->AddCoedge(C2, DTK_TRUE);
1294  F2->AddOuterLoop(L2);
1295 
1296  // Shell, Volume
1297  Dtk_ShellPtr SH = Dtk_Shell::Create(mysbody);
1298  SH->AddFace(F0, DTK_TRUE);
1299  SH->AddFace(F1, DTK_TRUE);
1300  SH->AddFace(F2, DTK_FALSE);
1301  // SH->info() = Dtk_Info::create();
1302  // SH->info()->SetColor(Dtk_RGB(0,255,0)); // OK
1303  Dtk_VolumePtr VOL = Dtk_Volume::Create(mysbody);
1304  VOL->AddOuterShell(SH);
1305  // VOL->info() = Dtk_Info::create();
1306  // VOL->info()->SetColor(Dtk_RGB(0,255,0)); // ne marche pas
1307  Dtk_LumpPtr Lump = Dtk_Lump::Create(mysbody);
1308  Lump->AddVolume(VOL);
1309  mysbody->AddLump(Lump);
1310  if (mysbody->info().IsNULL()) mysbody->info() = Dtk_Info::create();
1311  mysbody->info()->SetColor(Dtk_RGB(0, 255, 0)); // couleur globale : sur le body
1312 
1313  return mysbody;
1314  }

◆ CreateEsquisse2D()

Dtk_BodyPtr sampleWriter::CreateEsquisse2D ( )
1626  {
1627  Dtk_tab<Dtk_CurvePtr> ArrayCurve;
1628  Dtk_tab<Dtk_PointPtr> ArrayPoint;
1629 
1630  Dtk_PointPtr mypoint;
1631  mypoint = Dtk_Point::Create( Dtk_pnt( 1.0, 2.0, 0.0 ) );
1632  ArrayPoint.push_back( mypoint );
1633 
1634  Dtk_LinePtr line = Dtk_Line::Create( Dtk_pnt( 0.000000, 0.0, 0.0 ), Dtk_pnt( 1.0, 0.0, 0.0 ) );
1635  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( line ) );
1636  line = Dtk_Line::Create( Dtk_pnt( 1.0, 1.0, 0.0 ), Dtk_pnt( 0.0, 1.0, 0.0 ) );
1637  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( line ) );
1638 
1639  Dtk_EllipsePtr myarccircle;
1640  myarccircle = Dtk_Ellipse::Create( Dtk_pnt( 1.0, 0.5, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 0.5, 0.5 );
1641  myarccircle->SetTrimmingParameters( -1.0*DTK_PI / 2.0, DTK_PI / 2.0 );
1642  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myarccircle ) );
1643 
1644  myarccircle = Dtk_Ellipse::Create( Dtk_pnt( 0.0, 0.5, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 0.5, 0.5 );
1645  myarccircle->SetTrimmingParameters( DTK_PI / 2.0, 3.0*DTK_PI / 2.0 );
1646  Dtk_NurbsCurvePtr nurbs = myarccircle->ToNurbs();
1647  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( nurbs ) );
1648 
1649  Dtk_EllipsePtr mycircle;
1650  mycircle = Dtk_Ellipse::Create( Dtk_pnt( -0.125, 0.5, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 0.25 );
1651  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( mycircle ) );
1652 
1653  Dtk_EllipsePtr myellipse;
1654  myellipse = Dtk_Ellipse::Create( Dtk_pnt( 0.5, 0.25, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 0.25, 0.1 );
1655  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
1656 
1657  Dtk_EllipsePtr myarcellipse;
1658  myarcellipse = Dtk_Ellipse::Create( Dtk_pnt( 0.5, 0.75, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 0.25, 0.1 );
1659  myarcellipse->SetTrimmingParameters( -1.0*DTK_PI / 2.0, DTK_PI / 2.0 );
1660  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myarcellipse ) );
1661 
1662  myarcellipse = Dtk_Ellipse::Create( Dtk_pnt( 0.5, 0.75, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 0.25, 0.1 );
1663  myarcellipse->SetTrimmingParameters( DTK_PI / 2.0, 3.0*DTK_PI / 2.0 );
1664  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myarcellipse ) );
1665 
1666 
1667  Dtk_BodyPtr mybody;
1668  mybody = Dtk_Body::Create();
1669 
1670  Dtk_ShellPtr myshell;
1671  myshell = Dtk_Shell::Create( mybody );
1672 
1673  myshell->AddWire( ArrayPoint );
1674  myshell->AddWire( ArrayCurve );
1675 
1676  mybody->AddWireShell( myshell );
1677 
1678  mybody->info() = Dtk_Info::create();
1679  mybody->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
1680  mybody->info()->SetName( L"CreateEsquisse2D" );
1681 
1682  Dtk_transfo transfo;
1683  transfo.setOrigin( -100.0, 0.0, 0.0 );
1684  transfo.setScale( 10.0 );
1685  mybody->Transform( transfo );
1686 
1687  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of esquisse2d", L"Value of esquisse2d" );
1688  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
1689  ArrayMetadataEntity.push_back( metadata );
1690  mybody->info()->SetMetaData( ArrayMetadataEntity );
1691 
1692  return mybody;
1693  }

◆ CreateEsquisse3D()

Dtk_BodyPtr sampleWriter::CreateEsquisse3D ( )
1525  {
1526  Dtk_Size_t NbPoint = 2;
1527  Dtk_Size_t NbLine = 2;
1528  Dtk_Size_t Nbspline = 2;
1529  Dtk_Size_t NbCircle = 2;
1530  Dtk_Size_t NbArcCircle = 2;
1531  Dtk_Size_t NbEllipse = 2;
1532  Dtk_Size_t NbArcEllipse = 2;
1533 
1534 
1535  Dtk_tab<Dtk_PointPtr> ArrayPoint;
1536  Dtk_tab<Dtk_CurvePtr> ArrayCurve;
1537 
1538 
1539  for( Dtk_Size_t i = 0; i < NbPoint; i++ )
1540  {
1541  Dtk_PointPtr mypoint;
1542  mypoint = Dtk_Point::Create( Dtk_pnt( -10.0 + 10 * i, 2.0, 12.0 ) );
1543  mypoint->info() = Dtk_Info::create();
1544  mypoint->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
1545  Dtk_string name( L"mypoint" );
1546  name.add_int( (int) i );
1547  mypoint->info()->SetName( name );
1548  ArrayPoint.push_back( mypoint );
1549  }
1550 
1551 
1552  Dtk_tab<Dtk_LinePtr> arraylineptr;
1553  for( Dtk_Size_t i = 0; i < NbLine; i++ )
1554  {
1555  Dtk_LinePtr line = Dtk_Line::Create( Dtk_pnt( -10.0 + 10 * i, 3, 10.0 ), Dtk_pnt( -10.0 + 10 * i, 9, 0.0 ) );
1556  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( line ) );
1557  }
1558 
1559  for( Dtk_Size_t i = 0; i < Nbspline; i++ )
1560  {
1561  //add nurbs curve
1562  Dtk_EllipsePtr myellipse;
1563  myellipse = Dtk_Ellipse::Create( Dtk_pnt( -10.0 + 10 * i, 15, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 4.0, 2.5 );
1564  Dtk_NurbsCurvePtr nurbs = myellipse->ToNurbs();
1565  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( nurbs ) );
1566  }
1567 
1568  for( Dtk_Size_t i = 0; i < NbCircle; i++ )
1569  {
1570  //add nurbs curve
1571  Dtk_EllipsePtr myellipse;
1572  myellipse = Dtk_Ellipse::Create( Dtk_pnt( -10.0 + 10 * i, 22, 5.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 4.0 );
1573  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
1574  }
1575 
1576  for( Dtk_Size_t i = 0; i < NbArcCircle; i++ )
1577  {
1578  //add nurbs curve
1579  Dtk_EllipsePtr myellipse;
1580  myellipse = Dtk_Ellipse::Create( Dtk_pnt( -10.0 + 10 * i, 30, 5.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 3.0 );
1581  myellipse->SetTrimmingParameters( 0.0, DTK_PI );
1582  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
1583  }
1584 
1585  for( Dtk_Size_t i = 0; i < NbEllipse; i++ )
1586  {
1587  Dtk_EllipsePtr myellipse;
1588  myellipse = Dtk_Ellipse::Create( Dtk_pnt( -10.0 + 10 * i, 35, 3.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 3.0, 1.0 );
1589  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
1590  }
1591 
1592  for( Dtk_Size_t i = 0; i < NbArcEllipse; i++ )
1593  {
1594  Dtk_EllipsePtr myellipse;
1595  myellipse = Dtk_Ellipse::Create( Dtk_pnt( -10.0 + 10 * i, 40, 2.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 3.0, 1.0 );
1596  myellipse->SetTrimmingParameters( 0.0, DTK_PI );
1597  ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
1598  }
1599 
1600  Dtk_BodyPtr mybody;
1601  mybody = Dtk_Body::Create();
1602 
1603  Dtk_ShellPtr myshell;
1604  myshell = Dtk_Shell::Create( mybody );
1605 
1606  myshell->AddWire( ArrayPoint );
1607  myshell->AddWire( ArrayCurve );
1608 
1609  mybody->AddWireShell( myshell );
1610 
1611  mybody->info() = Dtk_Info::create();
1612  mybody->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
1613  mybody->info()->SetName( L"CreateEsquisse3D" );
1614 
1615  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of esquisse3d", L"Value of esquisse3d" );
1616  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
1617  ArrayMetadataEntity.push_back( metadata );
1618  mybody->info()->SetMetaData( ArrayMetadataEntity );
1619 
1620  return mybody;
1621  }

◆ CreateFdtDatum()

Dtk_FdtPtr sampleWriter::CreateFdtDatum ( )

Create Simple Datum.

20  {
21  Dtk_FdtPtr fdt = Dtk_Fdt::Create();
22 
23  // Creation of Leader line
24  Dtk_pnt arrow_location(0., 0.);
25  Dtk_tab<Dtk_pnt> leader_points;
26  leader_points.push_back(Dtk_pnt(0., 18.));
27  //Creation of leader with terminator's height and width 2.0. The terminator is a filled triangle
28  Dtk_LeaderPtr leader = Dtk_Leader::Create(2.0, 2.0, arrow_location, Dtk_Leader::TerminatorTypeClosedArrow, leader_points);
29  //Creation of symbol
30  Dtk_SymbolPtr symbol = Dtk_Symbol::Create();
31 
32  // Creation of Text info
33  Dtk_InfoPtr text_info = Dtk_Info::create();
34  //Setting text color to blue
35  text_info->SetColor(0, 0, 255);
36  //Setting text style
37  Dtk_bool horiz_vert = 0, mirror = 0, font_index = 0;
38  double slant = 0.;
39  Dtk_TextStyle text_style;
40  //Text height
41  text_style.CharHeight() = 3.5;
42  //Text width
43  text_style.CharWidth() = 2.1;
44  //Text slant
45  text_style.Slant() = slant;
46 
47  //Text value : "A"
48  Dtk_string str("A");
49  //Creating text 2D Bounding box
50  Dtk_pnt location(-2., 20.);
51  double XLen = 5., YLen = 5.;
52  Dtk_dir XDir(1., 0., 0.), YDir(0., 0., 1.);
53  Dtk_Oriented2dBBox inbox(location, XLen, YLen, XDir, YDir);
54 
55  Dtk_anchor_type dtk_align = DTK_ANCHOR_MIDDLE_CENTER;
56  DTK_Text_type text_type = dtk_text_type_value;
57 
58  //Creating the text itself giving :
59  // - its value
60  // - inside and outside boxes
61  // - anchor type
62  // - text type
63  // - horizontal/vertical text orientation
64  // - text infos
65  // - text style
66  // - text slant - PI / 2.0 for normal text -
67  // - font index
68  // - mirroring type
69  Dtk_Text dtk_text(str, inbox, inbox, dtk_align, text_type, horiz_vert, text_info, text_style, slant, font_index, mirror);
70 
71  //Adding created text to symbol
72  Dtk_CompositeText& texts = symbol->Texts();
73  texts.AddText(dtk_text);
74 
75  //Creating the frame of the text
76  Dtk_tab< Dtk_CurvePtr > FrameGeoms;
77  Dtk_PolylinePtr framePolyline;
78  framePolyline = Dtk_Polyline::Create(Dtk_pnt(-5., 18.), Dtk_pnt(5., 18.));
79  framePolyline->AddPoint(Dtk_pnt(5., 28.));
80  framePolyline->AddPoint(Dtk_pnt(-5., 28.));
81  framePolyline->AddPoint(Dtk_pnt(-5., 18.));
82  FrameGeoms.push_back(Dtk_CurvePtr::DtkDynamicCast(framePolyline));
83  //Setting the type of the frame
84  symbol->SetFrameType(DTK_FRAME_TYPE_RECTANGLE, FrameGeoms);
85 
86  // Creation of leader line
87  Dtk_InfoPtr leader_info = Dtk_Info::create();
88  leader_info->SetColor(255, 255, 255);
89  leader->GetInfo() = leader_info;
90  //Adding leader to symbol
91  symbol->AddLeader(leader);
92  //Setting symbol type
93  symbol->SymbolType() = Dtk_Symbol::TypeDatum;
94  //Adding symbol to FDT
95  fdt->Sub2DEntity() = Dtk_2dEntityPtr::DtkDynamicCast(symbol);
96 
97  //Adding transformation on FDT
98  Dtk_transfo fdt_transf;
99  fdt_transf.setOrigin(Dtk_pnt(50., 100., 50.));
100  fdt->Transform(fdt_transf);
101 
102  //Adding infos on FDT (Name and color)
103  Dtk_InfoPtr fdt_info = Dtk_Info::create();
104  fdt_info->SetColor(255, 255, 255);
105  fdt_info->SetName("Datum:1");
106  fdt->info() = fdt_info;
107 
108  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData(Dtk_MetaData::TypeProperty, L"Title of mydatum", L"Value of mydatum");
109  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
110  ArrayMetadataEntity.push_back(metadata);
111  fdt->info()->SetMetaData(ArrayMetadataEntity);
112 
113  return fdt;
114  }

◆ CreateFdtDimAssy()

Dtk_FdtPtr sampleWriter::CreateFdtDimAssy ( )

PMI in Assembly : a dimension between faces of different instances.

119  {
120  Dtk_FdtPtr fdt = Dtk_Fdt::Create();
121 
122  Dtk_SymbolPtr symbol = Dtk_Symbol::Create();
123 
124 
125  // Creation of Text info
126  Dtk_InfoPtr text_info = Dtk_Info::create();
127 
128  //Setting text style
129  Dtk_bool horiz_vert = 0, mirror = 0, font_index = 0;
130  double slant = 0.;
131  Dtk_TextStyle text_style;
132  //Text height
133  text_style.CharHeight() = 3.5;
134  //Text width
135  text_style.CharWidth() = 2.1;
136  //Text slant
137  text_style.Slant() = slant;
138 
139  //Creating text value "200"
140  Dtk_string str("200");
141  //Creating text 2D Bounding box
142  Dtk_pnt location(-5., 20.);
143  double x_len = 15., y_len = 5.;
144  Dtk_dir x_dir(1., 0., 0.), y_dir(0., 0., 1.);
145  Dtk_Oriented2dBBox inbox(location, x_len, y_len, x_dir, y_dir);
146 
147  Dtk_anchor_type dtk_align = DTK_ANCHOR_MIDDLE_CENTER;
148  DTK_Text_type text_type = dtk_text_type_value;
149 
150  //Creating the text itself giving :
151  // - its value
152  // - inside and outside boxes
153  // - anchor type
154  // - text type
155  // - horizontal/vertical text orientation
156  // - text infos
157  // - text style
158  // - text slant - PI / 2.0 for normal text -
159  // - font index
160  // - mirroring type
161  Dtk_Text dtk_text(str, inbox, inbox, dtk_align, text_type, horiz_vert, text_info, text_style, slant, font_index, mirror);
162  Dtk_CompositeText texts;
163  texts.AddText(dtk_text);
164 
165  //Creating the Dimension itself
166  Dtk_Dimension::DimensionTypeEnum dimensionType = Dtk_Dimension::DistanceDimension;
167  Dtk_DimensionPtr dimension = Dtk_Dimension::Create(dimensionType, texts);
168  //Adding dimension to FDT
169  fdt->Sub2DEntity() = Dtk_2dEntityPtr::DtkDynamicCast(dimension);
170 
171  //Creating the Leader lines
172  //Setting leader terminator type
173  Dtk_Leader::LeaderTerminatorTypeEnum termintator_type = Dtk_Leader::TerminatorTypeClosedArrow;
174  //Setting leader terminator size
175  double arrow_width = 5., arrow_length = 5.;
176  //Creating first leader
177  //Setting the Arrow location
178  Dtk_pnt leader1_arrow_location = Dtk_pnt(100., 23., 0.);
179  //Setting the leader position
180  Dtk_transfo leader1_pos;
181  leader1_pos.setOrigin(Dtk_pnt(0., 23., 0.));
182  //Setting the leader points
183  Dtk_tab<Dtk_pnt> leader1_pts;
184  leader1_pts.push_back(Dtk_pnt(10., 23., 0.));
185  //Creating the first leader itself
186  Dtk_LeaderPtr leader1 = Dtk_Leader::Create(arrow_width, arrow_length, leader1_arrow_location, termintator_type, leader1_pts);
187  //Adding extension lines
188  Dtk_tab<Dtk_pnt> extension_line_1;
189  extension_line_1.push_back(Dtk_pnt(100., 25.));
190  extension_line_1.push_back(Dtk_pnt(100., 0.));
191  dimension->AddLeaderWithExtensionLine(leader1, extension_line_1);
192 
193  //Creating second leader
194  Dtk_transfo leader2_pos;
195  leader2_pos.setOrigin(Dtk_pnt(0., 23., 0.));
196  Dtk_tab<Dtk_pnt> leader2_pts;
197  //Setting the Arrow location
198  Dtk_pnt leader2_arrow_location = Dtk_pnt(-100., 23., 0.);
199  leader2_pts.push_back(Dtk_pnt(-10., 23., 0.));
200  //Creating the second leader itself
201  Dtk_LeaderPtr leader2 = Dtk_Leader::Create(arrow_width, arrow_length, leader2_arrow_location, termintator_type, leader2_pts);
202  //Adding extension lines
203  Dtk_tab<Dtk_pnt> extension_line_2;
204  extension_line_2.push_back(Dtk_pnt(-100., 25.));
205  extension_line_2.push_back(Dtk_pnt(-100., 0.));
206  dimension->AddLeaderWithExtensionLine(leader2, extension_line_2);
207 
208  // General data of the FDT : position, color, name ..
209  Dtk_transfo fdt_transf;
210  fdt_transf.setOrigin(Dtk_pnt(0., 200., 75.));
211  fdt_transf.setXdir(0., 1., 0.);
212  fdt_transf.setYdir(-1., 0., 0.);
213  fdt->Transform(fdt_transf);
214 
215  Dtk_InfoPtr fdt_info = Dtk_Info::create();
216  fdt_info->SetColor(0, 255, 0);
217  fdt_info->SetName("Dimension:1");
218  fdt->info() = fdt_info;
219 
220  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData(Dtk_MetaData::TypeProperty, L"Title of myfdt", L"Value of myfdt");
221  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
222  ArrayMetadataEntity.push_back(metadata);
223  fdt->info()->SetMetaData(ArrayMetadataEntity);
224 
225  return fdt;
226  }

◆ CreateInfinitePlane()

Dtk_BodyPtr sampleWriter::CreateInfinitePlane ( )
1436  {
1437  Dtk_BodyPtr mybody = Dtk_Body::Create();
1438  mybody->info() = Dtk_Info::create();
1439  mybody->info()->SetInfiniteGeometryFlag( DTK_TRUE );
1440  mybody->get_info()->SetRefEntityFlag( DTK_TRUE );
1441 
1442  mybody->info()->SetColor( Dtk_RGB( 255, 0, 0, 255 ) );
1443  mybody->info()->SetName( L"myplan" );
1444 
1445  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of myplan", L"Value of myplan" );
1446  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
1447  ArrayMetadataEntity.push_back( metadata );
1448  mybody->info()->SetMetaData( ArrayMetadataEntity );
1449 
1450  Dtk_PlaneSurfacePtr plane = Dtk_PlaneSurface::Create( Dtk_pnt( -11, -12, -13 ), Dtk_dir( 0, 0, 1 ), Dtk_dir( 0, 1, 0 ) );
1451  Dtk_Double64 dom[ 4 ];
1452  dom[ 0 ] = 0.0;
1453  dom[ 1 ] = 10.0;
1454  dom[ 2 ] = 0.0;
1455  dom[ 3 ] = 10.0;
1456 
1457  plane->SetTrimUVBox( dom );
1458 
1459  mybody->AddUnboundedFace( Dtk_SurfacePtr::DtkDynamicCast( plane ) );
1460 
1461  return mybody;
1462  }

◆ CreateMeshCube()

Dtk_MeshPtr sampleWriter::CreateMeshCube ( )

Mesh Cube sample.

208  {
209  // Variables
210  Dtk_tab<Dtk_pnt> vertices;
211  Dtk_tab<Dtk_dir> normals;
212  Dtk_tab<Dtk_UInt32> indices;
213  Dtk_tab<Dtk_Float32> uCoords;
214  Dtk_tab<Dtk_Float32> vCoords;
215 
216  // Our mesh
217  Dtk_mesh* outCubeMesh = new Dtk_mesh( DTK_MESH_XYZ | DTK_MESH_NORMAL | DTK_MESH_UV_TEXTURES /*if you have materials*/ ); // coords & normals & materials
218 
219  // PART1 : CREATING GEOMETRY AND UV COORDINATES ARRAYS (HARD CODED here)
220  CreateMeshCubeGeometry( vertices, normals, uCoords, vCoords );
221 
222 
223  // PART2 : STORING geometry (vertices & normals) into the mesh
224 
225  for( Dtk_Size_t i = 0; i < vertices.size(); i++ )
226  {
227  outCubeMesh->add_vertex( &( vertices.at( i ) ), &( normals.at( i ) ), NULL, uCoords[ i ], vCoords[ i ] );
228  }
229 
230  // At this point, vertices & normals are stored, but we have no faces yet
231 
232  // PART3 : BUILDING THE SIX FACES
233  CreateMeshCubeFaces( outCubeMesh );
234 
235  Dtk_RGB rgb( 255, 0, 0 );
236  outCubeMesh->set_mesh_color( rgb ); // red cube
237  outCubeMesh->info() = Dtk_Info::create();
238  outCubeMesh->info()->SetColor( rgb );
239 
240  return outCubeMesh;
241  }

◆ CreateMeshCubeFaces()

void sampleWriter::CreateMeshCubeFaces ( Dtk_mesh *  outCubeMesh)

Create Mesh Faces For Cube.

188  {
189  Dtk_tab<Dtk_UInt32> indices;
190  int nbfaces = 6;
191  for( int i = 0; i < nbfaces; i++ )
192  {
193  indices.clear();
194  indices.push_back( i * 4 );
195  indices.push_back( i * 4 + 1 );
196  indices.push_back( i * 4 + 2 );
197  indices.push_back( i * 4 + 3 );
198 
199  Dtk_mesh_face * face = new Dtk_mesh_face( outCubeMesh );
200  face->add_triangle_strip( &indices );
201  outCubeMesh->add_mesh_face( face );
202  }
203 
204  }

◆ CreateMeshCubeGeometry()

void sampleWriter::CreateMeshCubeGeometry ( Dtk_tab< Dtk_pnt > &  vertices,
Dtk_tab< Dtk_dir > &  normals,
Dtk_tab< Dtk_Float32 > &  uCoords,
Dtk_tab< Dtk_Float32 > &  vCoords 
)

Create Mesh Geometry For Cube.

18  {
19  //Creating vertices and normals
20  vertices.push_back( Dtk_pnt( -1.0f, -1.0f, -1.0f ) );
21  vertices.push_back( Dtk_pnt( -1.0f, 1.0f, -1.0f ) ); //0.,0.,-1.
22  vertices.push_back( Dtk_pnt( 1.0f, -1.0f, -1.0f ) );
23  vertices.push_back( Dtk_pnt( 1.0f, 1.0f, -1.0f ) );
24  for( int i = 0; i < 4; i++ )
25  {
26  normals.push_back( Dtk_dir( 0., 0., -1. ) );
27  }
28 
29  vertices.push_back( Dtk_pnt( 1.0f, 1.0f, 1.0f ) );
30  vertices.push_back( Dtk_pnt( -1.0f, 1.0f, 1.0f ) ); //0.,0.,1.
31  vertices.push_back( Dtk_pnt( 1.0f, -1.0f, 1.0f ) );
32  vertices.push_back( Dtk_pnt( -1.0f, -1.0f, 1.0f ) );
33  for( int i = 0; i < 4; i++ )
34  {
35  normals.push_back( Dtk_dir( 0., 0., 1. ) );
36  }
37 
38  vertices.push_back( Dtk_pnt( -1.0f, 1.0f, -1.0f ) );
39  vertices.push_back( Dtk_pnt( -1.0f, 1.0f, 1.0f ) ); //0.,1.,0.
40  vertices.push_back( Dtk_pnt( 1.0f, 1.0f, -1.0f ) );
41  vertices.push_back( Dtk_pnt( 1.0f, 1.0f, 1.0f ) );
42  for( int i = 0; i < 4; i++ )
43  {
44  normals.push_back( Dtk_dir( 0., 1., 0. ) );
45  }
46 
47  vertices.push_back( Dtk_pnt( 1.0f, -1.0f, 1.0f ) );
48  vertices.push_back( Dtk_pnt( -1.0f, -1.0f, 1.0f ) ); //0.,-1.,0.
49  vertices.push_back( Dtk_pnt( 1.0f, -1.0f, -1.0f ) );
50  vertices.push_back( Dtk_pnt( -1.0f, -1.0f, -1.0f ) );
51  for( int i = 0; i < 4; i++ )
52  {
53  normals.push_back( Dtk_dir( 0., -1., 0. ) );
54  }
55 
56  vertices.push_back( Dtk_pnt( 1.0f, -1.0f, -1.0f ) );
57  vertices.push_back( Dtk_pnt( 1.0f, 1.0f, -1.0f ) ); //1.,0.,0.
58  vertices.push_back( Dtk_pnt( 1.0f, -1.0f, 1.0f ) );
59  vertices.push_back( Dtk_pnt( 1.0f, 1.0f, 1.0f ) );
60  for( int i = 0; i < 4; i++ )
61  {
62  normals.push_back( Dtk_dir( 1., 0., 0. ) );
63  }
64 
65  vertices.push_back( Dtk_pnt( -1.0f, 1.0f, 1.0f ) );
66  vertices.push_back( Dtk_pnt( -1.0f, 1.0f, -1.0f ) ); //-1.,0.,0.
67  vertices.push_back( Dtk_pnt( -1.0f, -1.0f, 1.0f ) );
68  vertices.push_back( Dtk_pnt( -1.0f, -1.0f, -1.0f ) );
69  for( int i = 0; i < 4; i++ )
70  {
71  normals.push_back( Dtk_dir( -1., 0., 0. ) );
72  }
73 
74  //Creating UV coordinates for textures
75  for( int i = 0; i < 6; i++ )
76  {
77  Dtk_Float32 len = 1.0;
78  uCoords.push_back( 0.0 );
79  vCoords.push_back( 0.0 );
80  uCoords.push_back( len );
81  vCoords.push_back( 0.0 );
82  uCoords.push_back( len );
83  vCoords.push_back( len );
84  uCoords.push_back( 0.0 );
85  vCoords.push_back( len );
86  }
87  }

◆ CreateMeshCubeidGeometry()

void sampleWriter::CreateMeshCubeidGeometry ( Dtk_tab< Dtk_pnt > &  vertices,
Dtk_tab< Dtk_dir > &  normals,
Dtk_tab< Dtk_Float32 > &  uCoords,
Dtk_tab< Dtk_Float32 > &  vCoords,
Dtk_pair< Dtk_pnt, Dtk_pnt >  inPoints 
)

Create Mesh Geometry For Cuboid.

91  {
92  Dtk_Double64 inFirstX, inFirstY, inFirstZ;
93  Dtk_Double64 inSecondX, inSecondY, inSecondZ;
94  inPoints.first.GetXYZ( inFirstX, inFirstY, inFirstZ );
95  inPoints.second.GetXYZ( inSecondX, inSecondY, inSecondZ );
96 
97  //Creating vertices and normals
98  vertices.push_back( Dtk_pnt( inFirstX, inFirstY, inFirstZ ) );
99  vertices.push_back( Dtk_pnt( inFirstX, inSecondY, inFirstZ ) ); //0.,0.,-1.
100  vertices.push_back( Dtk_pnt( inSecondX, inFirstY, inFirstZ ) );
101  vertices.push_back( Dtk_pnt( inSecondX, inSecondY, inFirstZ ) );
102  for( int i = 0; i < 4; i++ )
103  {
104  normals.push_back( Dtk_dir( 0., 0., -1. ) );
105  }
106 
107  vertices.push_back( Dtk_pnt( inSecondX, inSecondY, inSecondZ ) );
108  vertices.push_back( Dtk_pnt( inFirstX, inSecondY, inSecondZ ) ); //0.,0.,1.
109  vertices.push_back( Dtk_pnt( inSecondX, inFirstY, inSecondZ ) );
110  vertices.push_back( Dtk_pnt( inFirstX, inFirstY, inSecondZ ) );
111  for( int i = 0; i < 4; i++ )
112  {
113  normals.push_back( Dtk_dir( 0., 0., 1. ) );
114  }
115 
116  vertices.push_back( Dtk_pnt( inFirstX, inSecondY, inFirstZ ) );
117  vertices.push_back( Dtk_pnt( inFirstX, inSecondY, inSecondZ ) ); //0.,1.,0.
118  vertices.push_back( Dtk_pnt( inSecondX, inSecondY, inFirstZ ) );
119  vertices.push_back( Dtk_pnt( inSecondX, inSecondY, inSecondZ ) );
120  for( int i = 0; i < 4; i++ )
121  {
122  normals.push_back( Dtk_dir( 0., 1., 0. ) );
123  }
124 
125  vertices.push_back( Dtk_pnt( inSecondX, inFirstY, inSecondZ ) );
126  vertices.push_back( Dtk_pnt( inFirstX, inFirstY, inSecondZ ) ); //0.,-1.,0.
127  vertices.push_back( Dtk_pnt( inSecondX, inFirstY, inFirstZ ) );
128  vertices.push_back( Dtk_pnt( inFirstX, inFirstY, inFirstZ ) );
129  for( int i = 0; i < 4; i++ )
130  {
131  normals.push_back( Dtk_dir( 0., -1., 0. ) );
132  }
133 
134  vertices.push_back( Dtk_pnt( inSecondX, inFirstY, inFirstZ ) );
135  vertices.push_back( Dtk_pnt( inSecondX, inSecondY, inFirstZ ) ); //1.,0.,0.
136  vertices.push_back( Dtk_pnt( inSecondX, inFirstY, inSecondZ ) );
137  vertices.push_back( Dtk_pnt( inSecondX, inSecondY, inSecondZ ) );
138  for( int i = 0; i < 4; i++ )
139  {
140  normals.push_back( Dtk_dir( 1., 0., 0. ) );
141  }
142 
143  vertices.push_back( Dtk_pnt( inFirstX, inSecondY, inSecondZ ) );
144  vertices.push_back( Dtk_pnt( inFirstX, inSecondY, inFirstZ ) ); //-1.,0.,0.
145  vertices.push_back( Dtk_pnt( inFirstX, inFirstY, inSecondZ ) );
146  vertices.push_back( Dtk_pnt( inFirstX, inFirstY, inFirstZ ) );
147  for( int i = 0; i < 4; i++ )
148  {
149  normals.push_back( Dtk_dir( -1., 0., 0. ) );
150  }
151 
152  Dtk_Float32 lenX = ( Dtk_Float32 ) abs( inSecondX - inFirstX );
153  Dtk_Float32 lenY = ( Dtk_Float32 ) abs( inSecondY - inFirstY );
154  Dtk_Float32 lenZ = ( Dtk_Float32 ) abs( inSecondZ - inFirstZ );
155 
156  //Creating UV coordinates for textures
157  for( int i = 0; i < 6; i++ )
158  {
159  Dtk_Float32 len1, len2;
160  if( i < 2 )
161  {
162  len1 = lenX;
163  len2 = lenY;
164  }
165  else if( i < 4 )
166  {
167  len1 = lenX;
168  len2 = lenZ;
169  }
170  else
171  {
172  len1 = lenY;
173  len2 = lenZ;
174  }
175  uCoords.push_back( 0.0 );
176  vCoords.push_back( 0.0 );
177  uCoords.push_back( len1 );
178  vCoords.push_back( 0.0 );
179  uCoords.push_back( len1 );
180  vCoords.push_back( len2 );
181  uCoords.push_back( 0.0 );
182  vCoords.push_back( len2 );
183  }
184  }

◆ CreateMeshCubeVertexColor()

Dtk_MeshPtr sampleWriter::CreateMeshCubeVertexColor ( )
300  {
301  // Variables
302  Dtk_tab<Dtk_pnt> vertices;
303  Dtk_tab<Dtk_dir> normals;
304  Dtk_tab<Dtk_Float32> uCoords;
305  Dtk_tab<Dtk_Float32> vCoords;
306  Dtk_RGB red( 255, 0, 0 );
307  Dtk_RGB green( 0, 255, 0 );
308  Dtk_RGB blue( 0, 0, 255 );
309  Dtk_RGB all( 255, 255, 255 );
310 
311  // Our mesh
312  Dtk_mesh* outCubeMesh = new Dtk_mesh( DTK_MESH_XYZ | DTK_MESH_NORMAL | DTK_MESH_RGB ); // coords & normals & vertex colors
313 
314  // PART1 : CREATING GEOMETRY ARRAYS (HARD CODED here)
315  CreateMeshCubeGeometry( vertices, normals, uCoords, vCoords );
316 
317  // PART2 : STORING geometry (vertices & normals & vertex color) into the mesh
318 
319  for( Dtk_Size_t i = 0; i < vertices.size(); i += 4 )
320  {
321 
322  outCubeMesh->add_vertex( &( vertices.at( i ) ), &( normals.at( i ) ), &red );
323  outCubeMesh->add_vertex( &( vertices.at( i + 1 ) ), &( normals.at( i + 1 ) ), &green );
324  outCubeMesh->add_vertex( &( vertices.at( i + 2 ) ), &( normals.at( i + 2 ) ), &blue );
325  outCubeMesh->add_vertex( &( vertices.at( i + 3 ) ), &( normals.at( i + 3 ) ), &all );
326  }
327 
328  // At this point, vertices & normals are stored, but we have no faces yet
329 
330  // PART3 : BUILDING THE SIX FACES
331  CreateMeshCubeFaces( outCubeMesh );
332 
333  return outCubeMesh;
334  }

◆ CreateMeshCuboid()

Dtk_MeshPtr sampleWriter::CreateMeshCuboid ( const Dtk_pnt &  inFirstPoint,
const Dtk_pnt &  inSecondPoint 
)
459  {
460  // Variables
461  Dtk_tab<Dtk_pnt> vertices;
462  Dtk_tab<Dtk_dir> normals;
463  Dtk_tab<Dtk_UInt32> indices;
464  Dtk_tab<Dtk_Float32> uCoords;
465  Dtk_tab<Dtk_Float32> vCoords;
466 
467  // Our mesh
468  Dtk_mesh* outCuboidMesh = new Dtk_mesh( DTK_MESH_XYZ | DTK_MESH_NORMAL | DTK_MESH_UV_TEXTURES /*if you have materials*/ ); // coords & normals & materials
469 
470  Dtk_pair<Dtk_pnt, Dtk_pnt> inPoints = Dtk_pair<Dtk_pnt, Dtk_pnt>();
471  inPoints.first = inFirstPoint;
472  inPoints.second = inSecondPoint;
473 
474  // PART1 : CREATING GEOMETRY AND UV COORDINATES ARRAYS (HARD CODED here)
475  CreateMeshCubeidGeometry( vertices, normals, uCoords, vCoords, inPoints );
476 
477  // PART2 : STORING geometry (vertices & normals) into the mesh
478 
479  for( Dtk_Size_t i = 0; i < vertices.size(); i++ )
480  {
481  outCuboidMesh->add_vertex( &( vertices.at( i ) ), &( normals.at( i ) ), NULL, uCoords[ i ], vCoords[ i ] );
482  }
483 
484  // At this point, vertices & normals are stored, but we have no faces yet
485 
486  // PART3 : BUILDING THE SIX FACES
487  CreateMeshCubeFaces( outCuboidMesh );
488 
489  Dtk_RGB rgb( 255, 0, 0 );
490  outCuboidMesh->set_mesh_color( rgb ); // red cube
491  outCuboidMesh->info() = Dtk_Info::create();
492  outCuboidMesh->info()->SetColor( rgb );
493 
494  return outCuboidMesh;
495  }

◆ CreateMeshCylinder()

Dtk_MeshPtr sampleWriter::CreateMeshCylinder ( int  nbpoints)

Mesh Cylinder sample.

338  {
339  // Variables
340  Dtk_mesh_face * face = NULL;
341  Dtk_tab<Dtk_pnt> vertices;
342  Dtk_tab<Dtk_dir> normals;
343  Dtk_tab<Dtk_UInt32> indices;
344 
345  if( nbpoints < 3 )
346  {
347  return NULL;
348  }
349 
350  // Our mesh
351  Dtk_mesh* outCylinderMesh = new Dtk_mesh( DTK_MESH_XYZ | DTK_MESH_NORMAL ); // coords & normals
352 
353  Dtk_Size_t i;
354  double radius = 3;
355  double height = 5;
356  for( i = 0; i < ( Dtk_Size_t )nbpoints; i++ )
357  {
358  double angle = i * 2 * DTK_PI / nbpoints;
359  normals.push_back( Dtk_pnt( cos( angle ), sin( angle ), 0 ) );
360  vertices.push_back( radius*Dtk_pnt( cos( angle ), sin( angle ) ) + Dtk_pnt( 0, 0, height ) );
361  normals.push_back( Dtk_pnt( cos( angle ), sin( angle ), 0 ) );
362  vertices.push_back( radius*Dtk_pnt( cos( angle ), sin( angle ), 0 ) );
363  indices.push_back( ( Dtk_UInt32 )indices.size() );
364  indices.push_back( ( Dtk_UInt32 )indices.size() );
365  }
366  indices.push_back( 0 );
367  indices.push_back( 1 );
368 
369  face = new Dtk_mesh_face( outCylinderMesh );
370  face->add_triangle_strip( &indices, &vertices, &normals );
371  outCylinderMesh->add_mesh_face( face );
372 
373  Dtk_RGB rgb( 255, 255, 0, 128 );
374  outCylinderMesh->set_mesh_color( rgb ); // yellow transparent cylinder
375  outCylinderMesh->info() = Dtk_Info::create();
376  outCylinderMesh->info()->SetColor( rgb );
377 
378 
379  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mymesh", L"Value of mymesh" );
380  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
381  ArrayMetadataEntity.push_back( metadata );
382  outCylinderMesh->info()->SetMetaData( ArrayMetadataEntity );
383 
384  return outCylinderMesh;
385  }

◆ CreateMeshPoints()

Dtk_MeshPtr sampleWriter::CreateMeshPoints ( )

Points mesh sample.

440  {
441  Dtk_mesh* outPointMesh = new Dtk_mesh(DTK_MESH_XYZ); // coords
442  outPointMesh->info() = Dtk_Info::create();
443  outPointMesh->info()->SetColor(Dtk_RGB(255, 100, 0));
444  Dtk_mesh_face* face = new Dtk_mesh_face(outPointMesh);
445  double coords[8][3] = { {-1,-1,-1},{-1,-1,1},{-1,1,-1},{-1,1,1},
446  {1,-1,-1},{1,-1,1},{1,1,-1},{1,1,1} };
447  int i;
448  for (i = 0; i < 8; i++)
449  {
450  Dtk_pnt P(coords[i][0], coords[i][1], coords[i][2]);
451  outPointMesh->add_vertex(&P);
452  face->add_point(i);
453  }
454  outPointMesh->add_mesh_face(face);
455  return outPointMesh;
456  }

◆ CreateMeshWire()

Dtk_MeshPtr sampleWriter::CreateMeshWire ( )

Wire mesh sample.

389  {
390  // Variables
391  Dtk_mesh_face * face = NULL;
392  Dtk_tab<Dtk_pnt> vertices;
393  Dtk_tab<Dtk_dir> normals;
394  Dtk_tab<Dtk_UInt32> indices;
395  Dtk_Size_t i, numVertices;
396  Dtk_InfoPtr info = NULL;
397 
398  // Our mesh
399  Dtk_mesh* outWireMesh = new Dtk_mesh( DTK_MESH_XYZ ); // coords
400 
401  face = new Dtk_mesh_face( outWireMesh );
402 
403  //free curves
404  vertices.push_back( Dtk_pnt( -1.0f, 1.0f, 1.0f ) ); //0.,1.,0.
405  vertices.push_back( Dtk_pnt( -1.0f, 1.0f, -1.0f ) );
406  vertices.push_back( Dtk_pnt( 1.0f, 1.0f, -1.0f ) );
407  vertices.push_back( Dtk_pnt( 1.0f, 1.0f, 1.0f ) );
408 
409  numVertices = vertices.size();
410  for( i = 0; i < numVertices; i++ )
411  {
412  indices.push_back( ( Dtk_UInt32 )i );
413  }
414  indices.push_back( 0 );
415 
416  info = Dtk_Info::create();
417  info->SetColor( Dtk_RGB( 0, 0, 255 ) );
418  face->add_polyline( &indices, &vertices );
419  face->add_subinfo( info );
420  outWireMesh->add_mesh_face( face );
421 
422  //free vertex
423  info = NULL;
424  info = Dtk_Info::create();
425  vertices.clear();
426  indices.clear();
427  face = new Dtk_mesh_face( outWireMesh );
428  vertices.push_back( Dtk_pnt( 0.0f, 1.0f, 0.0f ) );
429  indices.push_back( 0 );
430  info->SetColor( Dtk_RGB( 255, 0, 0 ) );
431  face->add_points( &indices, &vertices );
432  face->add_subinfo( info );
433  outWireMesh->add_mesh_face( face );
434 
435  return outWireMesh;
436  }

◆ CreateModelDisplayActivated()

Dtk_ModelDisplayPtr sampleWriter::CreateModelDisplayActivated ( )
229  {
230  Dtk_ModelDisplayPtr resMD;
231  Dtk_pnt from = Dtk_pnt( 300, 300, 300 );
232  Dtk_pnt to( 0, 0, 0 );
233  Dtk_pnt up = Dtk_dir( -0.57735, 0.57735, -0.57735 );
234  Dtk_CameraPtr cam = Dtk_Camera::Create( from, to, 250, 250, up );
235  resMD = Dtk_ModelDisplay::Create( cam, NULL, 1 );// create activated model display
236  resMD->info() = Dtk_Info::create();
237  resMD->info()->SetName( "MyView1" );
238  return resMD;
239  }

◆ CreateModelDisplayDesactivated()

Dtk_ModelDisplayPtr sampleWriter::CreateModelDisplayDesactivated ( )
242  {
243  Dtk_ModelDisplayPtr resMD;
244  Dtk_pnt from( 0, 0, 100 );
245  Dtk_pnt to( 0, 0, 0 );
246  Dtk_dir up( 0, 1, 0 );
247  Dtk_CameraPtr cam = Dtk_Camera::Create( from, to, 100, 100, up ); // semiwidth = 100
248  resMD = Dtk_ModelDisplay::Create( cam, NULL, 0 ); // create desactivated model display
249  resMD->info() = Dtk_Info::create();
250  resMD->info()->SetName( "MyView2" );
251  return resMD;
252  }

◆ CreateModelDisplayWithSection()

Dtk_ModelDisplayPtr sampleWriter::CreateModelDisplayWithSection ( )
255  {
256  Dtk_ModelDisplayPtr resMD;
257  Dtk_PlaneSurfacePtr section = Dtk_PlaneSurface::Create( Dtk_pnt(), Dtk_dir( 0.75, -0.4, 0. ), Dtk_dir( 0., 0., 1. ) );
258  Dtk_ModelDisplayPtr mv1 = CreateModelDisplayActivated();
259  resMD = Dtk_ModelDisplay::Create( mv1->GetCamera(), Dtk_EntityPtr::DtkDynamicCast( section ), 0 ); // create second desactivated view with section
260  resMD->info() = Dtk_Info::create();
261  resMD->info()->SetName( "MySectionView" );
262 
263  return resMD;
264  }

◆ CreateOpenShell() [1/2]

Dtk_BodyPtr sampleWriter::CreateOpenShell ( )
1278  {
1279  Dtk_BodyPtr body = Dtk_Body::Create(); // create the Body
1280  Dtk_CylindricalSurfacePtr cyl = Dtk_CylindricalSurface::Create( Dtk_pnt( 0.0, 0.0, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 10.0 );
1281  Dtk_Double64 domain[] = { 0.0,3.14,-5.0,5.0 };
1282  cyl->SetTrimUVBox( domain );
1283  body->AddUnboundedFace( Dtk_SurfacePtr::DtkDynamicCast( cyl ) );
1284 
1285  //For an open shell you can also create an OpenShell and call
1286  //body->AddOpenShell(shell);
1287 
1288  return body;
1289  }

◆ CreateOpenShell() [2/2]

void sampleWriter::CreateOpenShell ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
1195  {
1196  Dtk_ShellPtr entity = NULL;
1197 
1198 
1199  /*Index 3*/
1200  entity = Dtk_Shell::Create( inDtkBody );// create the Shell
1201  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceABCD ] ), DTK_TRUE );// add the Face into the Shell
1202  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceABFE ] ), DTK_TRUE );// add the Face into the Shell
1203  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceFBDG ] ), DTK_TRUE );// add the Face into the Shell
1204  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceGDCH ] ), DTK_TRUE );// add the Face into the Shell
1205  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceEFGH ] ), DTK_TRUE );// add the Face into the Shell
1206 
1207  entity->SetClosedInfo( DTK_FALSE );
1208 
1209  outArrayTopo[ Shell ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1210  }

◆ CreateOpenShell_2() [1/2]

Dtk_BodyPtr sampleWriter::CreateOpenShell_2 ( )
1124  {
1125  Dtk_BodyPtr body = Dtk_Body::Create(); // create the Body
1126  Dtk_CylindricalSurfacePtr cyl = Dtk_CylindricalSurface::Create(Dtk_pnt(0.0, 0.0, 0.0), Dtk_dir(0.0, 0.0, 1.0), Dtk_dir(1.0, 0.0, 0.0), 10.0);
1127  Dtk_Double64 domain[] = { 0.0,3.14,-5.0,5.0 };
1128  cyl->SetTrimUVBox(domain);
1129  body->AddUnboundedFace(Dtk_SurfacePtr::DtkDynamicCast(cyl));
1130 
1131  //For an open shell you can also create an OpenShell and call
1132  //body->AddOpenShell(shell);
1133 
1134  return body;
1135  }

◆ CreateOpenShell_2() [2/2]

void sampleWriter::CreateOpenShell_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
1024  {
1025  Dtk_ShellPtr entity = NULL;
1026 
1027 
1028  /*Index 3*/
1029  entity = Dtk_Shell::Create(inDtkBody);// create the Shell
1030  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[5]), DTK_TRUE);// add the Face into the Shell
1031  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[33]), DTK_TRUE);// add the Face into the Shell
1032  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[55]), DTK_TRUE);// add the Face into the Shell
1033  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[73]), DTK_TRUE);// add the Face into the Shell
1034  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[91]), DTK_TRUE);// add the Face into the Shell
1035 
1036  entity->SetClosedInfo(DTK_FALSE);
1037 
1038  // test : properties on an open shell
1039  Dtk_InfoPtr& shell_info = entity->info();
1040  if (shell_info.IsNULL()) shell_info = Dtk_Info::create();
1041  /*
1042  Dtk_Val valprop_area("60000 mm2");
1043  shell_info->AddAttribute("geometric validation property : area : surface area measure",valprop_area);
1044  */
1045 
1046  outArrayTopo[3] = Dtk_EntityPtr::DtkDynamicCast(entity);
1047  }

◆ CreatePoint()

Dtk_BodyPtr sampleWriter::CreatePoint ( )
1408  {
1409  Dtk_tab<Dtk_PointPtr> mypoints;
1410  Dtk_BodyPtr mybody;
1411  mybody = Dtk_Body::Create();
1412 
1413  Dtk_ShellPtr myshell;
1414  myshell = Dtk_Shell::Create( mybody );
1415 
1416  Dtk_PointPtr mypoint;
1417  mypoint = Dtk_Point::Create( Dtk_pnt( -10.0, 11.0, 12.0 ) );
1418  mypoint->info() = Dtk_Info::create();
1419  mypoint->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
1420  mypoint->info()->SetName( "mypoint" );
1421 
1422  Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mypoint", L"Value of mypoint" );
1423  Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
1424  ArrayMetadataEntity.push_back( metadata );
1425  mypoint->info()->SetMetaData( ArrayMetadataEntity );
1426 
1427  mypoints.push_back( mypoint );
1428 
1429  myshell->AddWire( mypoints );
1430  mybody->AddWireShell( myshell );
1431  return mybody;
1432  }

◆ CreateTexturedMeshCube()

Dtk_MeshPtr sampleWriter::CreateTexturedMeshCube ( const Dtk_string &  inImageDirectory)

Textured Mesh Cube sample.

273  {
274  // Our mesh
275  Dtk_MeshPtr outCubeMesh = CreateMeshCube();
276 
277  // create mesh texture with cubical mapping
278  Dtk_RenderInfosPtr meshRender = Dtk_RenderInfos::Create( "meshRender" );
279  Dtk_TextureInfosPtr meshTexture = Dtk_TextureInfos::Create( Dtk_TextureInfos::CubicalMapping );
280  meshTexture->SetImagePath( inImageDirectory + "sample.bmp" );
281  meshTexture->SetScale( 2., 2. ); // image scale
282  meshRender->SetTexture( meshTexture );
283  outCubeMesh->info()->AddRenderInfos( meshRender ); // apply texture to mesh
284  outCubeMesh->info()->SetName( "TexturedMesh" );
285 
286  // create face render texture
287  Dtk_RenderInfosPtr faceRender = Dtk_RenderInfos::Create( "faceRender" );
288  Dtk_TextureInfosPtr faceTexture = Dtk_TextureInfos::Create( Dtk_TextureInfos::CubicalMapping );
289  faceTexture->SetImagePath( inImageDirectory + "logodtk.bmp" );
290  faceTexture->SetScale( 2., 2. ); // image scale
291  faceRender->SetTexture( faceTexture );
292  if( outCubeMesh->get_mesh_face( 2 )->info().IsNULL() )
293  outCubeMesh->get_mesh_face( 2 )->info() = Dtk_Info::create();
294  outCubeMesh->get_mesh_face( 2 )->info()->AddRenderInfos( faceRender ); // apply texture to face
295 
296  return outCubeMesh;
297  }

◆ CreateTopoCoEdge()

void sampleWriter::CreateTopoCoEdge ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
429  {
430  Dtk_CoedgePtr entity = NULL;
431  Dtk_LinePtr line = NULL;
432  Dtk_CurvePtr curve = NULL;
433  Dtk_tab<Dtk_pnt> ControlPoints;
434  Dtk_EdgePtr edge = NULL;
435 
436  /*nurbs with 2 ControlPoints*/
437  ControlPoints.resize( 2 );
438 
439  /*Into the 0 loop*/
440  /*Index 8 - Coedge0_AB*/
441  entity = Dtk_Coedge::Create( inDtkBody );
442  entity->info() = Dtk_Info::create();
443  entity->info()->SetName( L"Coedge0_AB" );
444 
445 
446  entity->SetOrientation( DTK_TRUE );
447 
448 
449  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
450  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
451  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
452  curve = Dtk_CurvePtr::DtkDynamicCast( line );
453  entity->SetGeom( curve );
454  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_AB ] ) );
455 
456  outArrayTopo[ Coedge0_AB ] = Dtk_EntityPtr::DtkDynamicCast( entity );
457 
458 
459  /*Index 16 - Coedge0_CA*/
460  entity = Dtk_Coedge::Create( inDtkBody );
461  entity->info() = Dtk_Info::create();
462  entity->info()->SetName( L"Coedge0_CA" );
463 
464 
465  entity->SetOrientation( DTK_TRUE );
466 
467  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
468  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
469  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
470  curve = Dtk_CurvePtr::DtkDynamicCast( line );
471  entity->SetGeom( curve );
472  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_CA ] ) );
473 
474  outArrayTopo[ Coedge0_CA ] = Dtk_EntityPtr::DtkDynamicCast( entity );
475 
476 
477 
478  /*Index 22 - Coedge0_DC*/
479  entity = Dtk_Coedge::Create( inDtkBody );
480  entity->info() = Dtk_Info::create();
481  entity->info()->SetName( L"Coedge0_CD" );
482 
483 
484  entity->SetOrientation( DTK_TRUE );
485 
486  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
487  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
488  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
489  curve = Dtk_CurvePtr::DtkDynamicCast( line );
490  entity->SetGeom( curve );
491  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_DC ] ) );
492 
493  outArrayTopo[ Coedge0_DC ] = Dtk_EntityPtr::DtkDynamicCast( entity );
494 
495 
496  /*Index 28 - Coedge0_BD*/
497  entity = Dtk_Coedge::Create( inDtkBody );
498  entity->info() = Dtk_Info::create();
499  entity->info()->SetName( L"Coedge0_BD" );
500 
501  entity->SetOrientation( DTK_TRUE );
502 
503  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
504  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
505  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
506  curve = Dtk_CurvePtr::DtkDynamicCast( line );
507  entity->SetGeom( curve );
508  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_BD ] ) );
509 
510  outArrayTopo[ Coedge0_BD ] = Dtk_EntityPtr::DtkDynamicCast( entity );
511 
512 
513 
514 
515  /*Into the 1 loop*/
516  /*Index 36 - Coedge1_EA*/
517  entity = Dtk_Coedge::Create( inDtkBody );
518  entity->info() = Dtk_Info::create();
519  entity->info()->SetName( L"Coedge1_EA" );
520 
521  entity->SetOrientation( DTK_TRUE );
522 
523  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
524  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
525  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
526  curve = Dtk_CurvePtr::DtkDynamicCast( line );
527  entity->SetGeom( curve );
528  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_EA ] ) );
529 
530  outArrayTopo[ Coedge1_EA ] = Dtk_EntityPtr::DtkDynamicCast( entity );
531 
532 
533  /*Index 42 - Coedge1_AB*/
534  entity = Dtk_Coedge::Create( inDtkBody );
535  entity->info() = Dtk_Info::create();
536  entity->info()->SetName( L"Coedge1_AB" );
537 
538  entity->SetOrientation( DTK_TRUE );
539 
540  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
541  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
542  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
543  curve = Dtk_CurvePtr::DtkDynamicCast( line );
544  entity->SetGeom( curve );
545  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_AB ] ) );
546 
547  outArrayTopo[ Coedge1_AB ] = Dtk_EntityPtr::DtkDynamicCast( entity );
548 
549 
550  /*Index 44 - Coedge1_FB*/
551  entity = Dtk_Coedge::Create( inDtkBody );
552  entity->info() = Dtk_Info::create();
553  entity->info()->SetName( L"Coedge1_FB" );
554 
555  entity->SetOrientation( DTK_TRUE );
556 
557  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
558  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
559  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
560  curve = Dtk_CurvePtr::DtkDynamicCast( line );
561  entity->SetGeom( curve );
562  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_FB ] ) );
563 
564  outArrayTopo[ Coedge1_FB ] = Dtk_EntityPtr::DtkDynamicCast( entity );
565 
566 
567  /*Index 50 - Coedge1_FE*/
568  entity = Dtk_Coedge::Create( inDtkBody );
569  entity->info() = Dtk_Info::create();
570  entity->info()->SetName( L"Coedge1_FE" );
571 
572 
573  entity->SetOrientation( DTK_TRUE );
574 
575  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
576  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
577  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
578  curve = Dtk_CurvePtr::DtkDynamicCast( line );
579  entity->SetGeom( curve );
580  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_FE ] ) );
581 
582  outArrayTopo[ Coedge1_FE ] = Dtk_EntityPtr::DtkDynamicCast( entity );
583 
584 
585 
586  /*Into the 2 loop*/
587  /*Index 58 - Coedge2_FB*/
588  entity = Dtk_Coedge::Create( inDtkBody );
589  entity->info() = Dtk_Info::create();
590  entity->info()->SetName( L"Coedge2_FB" );
591 
592 
593  entity->SetOrientation( DTK_TRUE );
594 
595  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
596  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
597  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
598  curve = Dtk_CurvePtr::DtkDynamicCast( line );
599  entity->SetGeom( curve );
600  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_FB ] ) );
601 
602  outArrayTopo[ Coedge2_FB ] = Dtk_EntityPtr::DtkDynamicCast( entity );
603 
604 
605  /*Index 60 - Coedge2_BD*/
606  entity = Dtk_Coedge::Create( inDtkBody );
607  entity->info() = Dtk_Info::create();
608  entity->info()->SetName( L"Coedge2_BD" );
609 
610 
611  entity->SetOrientation( DTK_TRUE );
612 
613  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
614  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
615  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
616  curve = Dtk_CurvePtr::DtkDynamicCast( line );
617  entity->SetGeom( curve );
618  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_BD ] ) );
619 
620  outArrayTopo[ Coedge2_BD ] = Dtk_EntityPtr::DtkDynamicCast( entity );
621 
622 
623  /*Index 62 - Coedge2_GD*/
624  entity = Dtk_Coedge::Create( inDtkBody );
625  entity->info() = Dtk_Info::create();
626  entity->info()->SetName( L"Coedge2_GD" );
627 
628  entity->SetOrientation( DTK_TRUE );
629 
630  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
631  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
632  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
633  curve = Dtk_CurvePtr::DtkDynamicCast( line );
634  entity->SetGeom( curve );
635  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_GD ] ) );
636 
637  outArrayTopo[ Coedge2_GD ] = Dtk_EntityPtr::DtkDynamicCast( entity );
638 
639 
640  /*Index 68 - Coedge2_GF*/
641  entity = Dtk_Coedge::Create( inDtkBody );
642  entity->info() = Dtk_Info::create();
643  entity->info()->SetName( L"Coedge2_GF" );
644 
645  entity->SetOrientation( DTK_TRUE );
646 
647  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
648  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
649  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
650  curve = Dtk_CurvePtr::DtkDynamicCast( line );
651  entity->SetGeom( curve );
652  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_GF ] ) );
653 
654  outArrayTopo[ Coedge2_GF ] = Dtk_EntityPtr::DtkDynamicCast( entity );
655 
656 
657 
658  /*Into the 3 loop*/
659  /*Index 76 - Coedge3_GD*/
660  entity = Dtk_Coedge::Create( inDtkBody );
661  entity->info() = Dtk_Info::create();
662  entity->info()->SetName( L"Coedge3_GD" );
663 
664  entity->SetOrientation( DTK_TRUE );
665 
666  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
667  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
668  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
669  curve = Dtk_CurvePtr::DtkDynamicCast( line );
670  entity->SetGeom( curve );
671  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_GD ] ) );
672 
673  outArrayTopo[ Coedge3_GD ] = Dtk_EntityPtr::DtkDynamicCast( entity );
674 
675 
676  /*Index 78 - Coedge3_DC*/
677  entity = Dtk_Coedge::Create( inDtkBody );
678  entity->info() = Dtk_Info::create();
679  entity->info()->SetName( L"Coedge3_DC" );
680 
681  entity->SetOrientation( DTK_TRUE );
682 
683  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
684  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
685  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
686  curve = Dtk_CurvePtr::DtkDynamicCast( line );
687  entity->SetGeom( curve );
688  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_DC ] ) );
689 
690  outArrayTopo[ Coedge3_DC ] = Dtk_EntityPtr::DtkDynamicCast( entity );
691 
692 
693  /*Index 80 - Coedge3_HC*/
694  entity = Dtk_Coedge::Create( inDtkBody );
695  entity->info() = Dtk_Info::create();
696  entity->info()->SetName( L"Coedge3_HC" );
697 
698 
699  entity->SetOrientation( DTK_TRUE );
700 
701  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
702  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
703  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
704  curve = Dtk_CurvePtr::DtkDynamicCast( line );
705  entity->SetGeom( curve );
706  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_HC ] ) );
707 
708  outArrayTopo[ Coedge3_HC ] = Dtk_EntityPtr::DtkDynamicCast( entity );
709 
710 
711  /*Index 86 - Coedge3_HG*/
712  entity = Dtk_Coedge::Create( inDtkBody );
713  entity->info() = Dtk_Info::create();
714  entity->info()->SetName( L"Coedge3_HG" );
715 
716  entity->SetOrientation( DTK_TRUE );
717 
718  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
719  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
720  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
721  curve = Dtk_CurvePtr::DtkDynamicCast( line );
722  entity->SetGeom( curve );
723  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_HG ] ) );
724 
725  outArrayTopo[ Coedge3_HG ] = Dtk_EntityPtr::DtkDynamicCast( entity );
726 
727 
728 
729 
730  /*Into the 4 loop*/
731  /*Index 94 - Coedge4_EH*/
732  entity = Dtk_Coedge::Create( inDtkBody );
733  entity->info() = Dtk_Info::create();
734  entity->info()->SetName( L"Coedge4_EH" );
735 
736  entity->SetOrientation( DTK_TRUE );
737 
738  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
739  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
740  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
741  curve = Dtk_CurvePtr::DtkDynamicCast( line );
742  entity->SetGeom( curve );
743  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_EH ] ) );
744 
745  outArrayTopo[ Coedge4_EH ] = Dtk_EntityPtr::DtkDynamicCast( entity );
746 
747 
748  /*Index 98 - Coedge4_FE*/
749  entity = Dtk_Coedge::Create( inDtkBody );
750  entity->info() = Dtk_Info::create();
751  entity->info()->SetName( L"Coedge4_FE" );
752 
753  entity->SetOrientation( DTK_TRUE );
754 
755  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
756  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
757  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
758  curve = Dtk_CurvePtr::DtkDynamicCast( line );
759  entity->SetGeom( curve );
760  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_FE ] ) );
761 
762  outArrayTopo[ Coedge4_FE ] = Dtk_EntityPtr::DtkDynamicCast( entity );
763 
764 
765  /*Index 100*/
766  entity = Dtk_Coedge::Create( inDtkBody );
767  entity->info() = Dtk_Info::create();
768  entity->info()->SetName( L"Coedge4_GF" );
769 
770  entity->SetOrientation( DTK_TRUE );
771 
772  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
773  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
774  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
775  curve = Dtk_CurvePtr::DtkDynamicCast( line );
776  entity->SetGeom( curve );
777  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_GF ] ) );
778 
779  outArrayTopo[ Coedge4_GF ] = Dtk_EntityPtr::DtkDynamicCast( entity );
780 
781 
782  /*Index 102 - Coedge4_HG*/
783  entity = Dtk_Coedge::Create( inDtkBody );
784  entity->info() = Dtk_Info::create();
785  entity->info()->SetName( L"Coedge4_HG" );
786 
787  entity->SetOrientation( DTK_TRUE );
788 
789  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
790  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
791  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
792  curve = Dtk_CurvePtr::DtkDynamicCast( line );
793  entity->SetGeom( curve );
794  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_HG ] ) );
795 
796  outArrayTopo[ Coedge4_HG ] = Dtk_EntityPtr::DtkDynamicCast( entity );
797 
798 
799 
800 
801  /*Into the 5 loop*/
802  /*Index 108 - Coedge5_EH*/
803  entity = Dtk_Coedge::Create( inDtkBody );
804  entity->info() = Dtk_Info::create();
805  entity->info()->SetName( L"Coedge5_EH" );
806 
807  entity->SetOrientation( DTK_TRUE );
808 
809  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
810  ControlPoints[ 1 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
811  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
812  curve = Dtk_CurvePtr::DtkDynamicCast( line );
813  entity->SetGeom( curve );
814  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_EH ] ) );
815 
816  outArrayTopo[ Coedge5_EH ] = Dtk_EntityPtr::DtkDynamicCast( entity );
817 
818 
819  /*Index 110*/
820  entity = Dtk_Coedge::Create( inDtkBody );
821  entity->info() = Dtk_Info::create();
822  entity->info()->SetName( L"Coedge5_HC" );
823 
824  entity->SetOrientation( DTK_TRUE );
825 
826  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 1.0, 0.0 );
827  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
828  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
829  curve = Dtk_CurvePtr::DtkDynamicCast( line );
830  entity->SetGeom( curve );
831  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_HC ] ) );
832 
833  outArrayTopo[ Coedge5_HC ] = Dtk_EntityPtr::DtkDynamicCast( entity );
834 
835 
836  /*Index 112 - Coedge5_CA*/
837  entity = Dtk_Coedge::Create( inDtkBody );
838  entity->info() = Dtk_Info::create();
839  entity->info()->SetName( L"Coedge5_CA" );
840 
841  entity->SetOrientation( DTK_TRUE );
842 
843  ControlPoints[ 0 ] = Dtk_pnt( 0.0, 1.0, 0.0 );
844  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
845  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
846  curve = Dtk_CurvePtr::DtkDynamicCast( line );
847  entity->SetGeom( curve );
848  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_CA ] ) );
849 
850  outArrayTopo[ Coedge5_CA ] = Dtk_EntityPtr::DtkDynamicCast( entity );
851 
852 
853  /*Index 114 - Coedge5_EA*/
854  entity = Dtk_Coedge::Create( inDtkBody );
855  entity->info() = Dtk_Info::create();
856  entity->info()->SetName( L"Coedge5_EA" );
857 
858  entity->SetOrientation( DTK_TRUE );
859 
860  ControlPoints[ 0 ] = Dtk_pnt( 1.0, 0.0, 0.0 );
861  ControlPoints[ 1 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
862  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
863  curve = Dtk_CurvePtr::DtkDynamicCast( line );
864  entity->SetGeom( curve );
865  entity->SetEdge( Dtk_EdgePtr::DtkDynamicCast( outArrayTopo[ Edge_EA ] ) );
866 
867  outArrayTopo[ Coedge5_EA ] = Dtk_EntityPtr::DtkDynamicCast( entity );
868 
869 
870  }

◆ CreateTopoCoEdge_2()

void sampleWriter::CreateTopoCoEdge_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
341  {
342  Dtk_CoedgePtr entity = NULL;
343  Dtk_LinePtr line = NULL;
344  Dtk_CurvePtr curve = NULL;
345  Dtk_tab<Dtk_pnt> ControlPoints;
346  Dtk_EdgePtr edge = NULL;
347 
348  /*nurbs with 2 ControlPoints*/
349  ControlPoints.resize(2);
350 
351  /*Into the 0 loop*/
352  /*Index 8*/
353  entity = Dtk_Coedge::Create(inDtkBody);
354 
355  entity->SetOrientation(DTK_TRUE);
356 
357  ControlPoints[0] = Dtk_pnt(1.0, 0.0, 0.0);
358  ControlPoints[1] = Dtk_pnt(0.0, 0.0, 0.0);
359  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
360  curve = Dtk_CurvePtr::DtkDynamicCast(line);
361  entity->SetGeom(curve);
362  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[14]));
363 
364  outArrayTopo[8] = Dtk_EntityPtr::DtkDynamicCast(entity);
365 
366 
367  /*Index 16*/
368  entity = Dtk_Coedge::Create(inDtkBody);
369 
370  entity->SetOrientation(DTK_TRUE);
371 
372  ControlPoints[0] = Dtk_pnt(1.0, 1.0, 0.0);
373  ControlPoints[1] = Dtk_pnt(1.0, 0.0, 0.0);
374  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
375  curve = Dtk_CurvePtr::DtkDynamicCast(line);
376  entity->SetGeom(curve);
377  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[20]));
378 
379  outArrayTopo[16] = Dtk_EntityPtr::DtkDynamicCast(entity);
380 
381 
382 
383  /*Index 22*/
384  entity = Dtk_Coedge::Create(inDtkBody);
385 
386  entity->SetOrientation(DTK_TRUE);
387 
388  ControlPoints[0] = Dtk_pnt(0.0, 1.0, 0.0);
389  ControlPoints[1] = Dtk_pnt(1.0, 1.0, 0.0);
390  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
391  curve = Dtk_CurvePtr::DtkDynamicCast(line);
392  entity->SetGeom(curve);
393  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[26]));
394 
395  outArrayTopo[22] = Dtk_EntityPtr::DtkDynamicCast(entity);
396 
397 
398  /*Index 28*/
399  entity = Dtk_Coedge::Create(inDtkBody);
400 
401  entity->SetOrientation(DTK_TRUE);
402 
403  ControlPoints[0] = Dtk_pnt(0.0, 0.0, 0.0);
404  ControlPoints[1] = Dtk_pnt(0.0, 1.0, 0.0);
405  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
406  curve = Dtk_CurvePtr::DtkDynamicCast(line);
407  entity->SetGeom(curve);
408  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[30]));
409 
410  outArrayTopo[28] = Dtk_EntityPtr::DtkDynamicCast(entity);
411 
412 
413 
414 
415  /*Into the 1 loop*/
416  /*Index 36*/
417  entity = Dtk_Coedge::Create(inDtkBody);
418 
419  entity->SetOrientation(DTK_TRUE);
420 
421  ControlPoints[0] = Dtk_pnt(1.0, 1.0, 0.0);
422  ControlPoints[1] = Dtk_pnt(0.0, 1.0, 0.0);
423  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
424  curve = Dtk_CurvePtr::DtkDynamicCast(line);
425  entity->SetGeom(curve);
426  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[40]));
427 
428  outArrayTopo[36] = Dtk_EntityPtr::DtkDynamicCast(entity);
429 
430 
431  /*Index 42*/
432  entity = Dtk_Coedge::Create(inDtkBody);
433 
434  entity->SetOrientation(DTK_TRUE);
435 
436  ControlPoints[0] = Dtk_pnt(0.0, 1.0, 0.0);
437  ControlPoints[1] = Dtk_pnt(0.0, 0.0, 0.0);
438  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
439  curve = Dtk_CurvePtr::DtkDynamicCast(line);
440  entity->SetGeom(curve);
441  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[14]));
442 
443  outArrayTopo[42] = Dtk_EntityPtr::DtkDynamicCast(entity);
444 
445 
446  /*Index 44*/
447  entity = Dtk_Coedge::Create(inDtkBody);
448 
449  entity->SetOrientation(DTK_TRUE);
450 
451  ControlPoints[0] = Dtk_pnt(1.0, 0.0, 0.0);
452  ControlPoints[1] = Dtk_pnt(0.0, 0.0, 0.0);
453  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
454  curve = Dtk_CurvePtr::DtkDynamicCast(line);
455  entity->SetGeom(curve);
456  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[48]));
457 
458  outArrayTopo[44] = Dtk_EntityPtr::DtkDynamicCast(entity);
459 
460 
461  /*Index 50*/
462  entity = Dtk_Coedge::Create(inDtkBody);
463 
464  entity->SetOrientation(DTK_TRUE);
465 
466  ControlPoints[0] = Dtk_pnt(1.0, 0.0, 0.0);
467  ControlPoints[1] = Dtk_pnt(1.0, 1.0, 0.0);
468  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
469  curve = Dtk_CurvePtr::DtkDynamicCast(line);
470  entity->SetGeom(curve);
471  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[52]));
472 
473  outArrayTopo[50] = Dtk_EntityPtr::DtkDynamicCast(entity);
474 
475 
476 
477  /*Into the 2 loop*/
478  /*Index 58*/
479  entity = Dtk_Coedge::Create(inDtkBody);
480 
481  entity->SetOrientation(DTK_TRUE);
482 
483  ControlPoints[0] = Dtk_pnt(0.0, 0.0, 0.0);
484  ControlPoints[1] = Dtk_pnt(1.0, 0.0, 0.0);
485  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
486  curve = Dtk_CurvePtr::DtkDynamicCast(line);
487  entity->SetGeom(curve);
488  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[48]));
489 
490  outArrayTopo[58] = Dtk_EntityPtr::DtkDynamicCast(entity);
491 
492 
493  /*Index 60*/
494  entity = Dtk_Coedge::Create(inDtkBody);
495 
496  entity->SetOrientation(DTK_TRUE);
497 
498  ControlPoints[0] = Dtk_pnt(1.0, 0.0, 0.0);
499  ControlPoints[1] = Dtk_pnt(1.0, 1.0, 0.0);
500  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
501  curve = Dtk_CurvePtr::DtkDynamicCast(line);
502  entity->SetGeom(curve);
503  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[30]));
504 
505  outArrayTopo[60] = Dtk_EntityPtr::DtkDynamicCast(entity);
506 
507 
508  /*Index 62*/
509  entity = Dtk_Coedge::Create(inDtkBody);
510 
511  entity->SetOrientation(DTK_TRUE);
512 
513  ControlPoints[0] = Dtk_pnt(0.0, 1.0, 0.0);
514  ControlPoints[1] = Dtk_pnt(1.0, 1.0, 0.0);
515  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
516  curve = Dtk_CurvePtr::DtkDynamicCast(line);
517  entity->SetGeom(curve);
518  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[66]));
519 
520  outArrayTopo[62] = Dtk_EntityPtr::DtkDynamicCast(entity);
521 
522 
523  /*Index 68*/
524  entity = Dtk_Coedge::Create(inDtkBody);
525 
526  entity->SetOrientation(DTK_TRUE);
527 
528  ControlPoints[0] = Dtk_pnt(0.0, 1.0, 0.0);
529  ControlPoints[1] = Dtk_pnt(0.0, 0.0, 0.0);
530  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
531  curve = Dtk_CurvePtr::DtkDynamicCast(line);
532  entity->SetGeom(curve);
533  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[70]));
534 
535  outArrayTopo[68] = Dtk_EntityPtr::DtkDynamicCast(entity);
536 
537 
538 
539  /*Into the 3 loop*/
540  /*Index 76*/
541  entity = Dtk_Coedge::Create(inDtkBody);
542 
543  entity->SetOrientation(DTK_TRUE);
544 
545  ControlPoints[0] = Dtk_pnt(0.0, 0.0, 0.0);
546  ControlPoints[1] = Dtk_pnt(1.0, 0.0, 0.0);
547  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
548  curve = Dtk_CurvePtr::DtkDynamicCast(line);
549  entity->SetGeom(curve);
550  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[66]));
551 
552  outArrayTopo[76] = Dtk_EntityPtr::DtkDynamicCast(entity);
553 
554 
555  /*Index 78*/
556  entity = Dtk_Coedge::Create(inDtkBody);
557 
558  entity->SetOrientation(DTK_TRUE);
559 
560  ControlPoints[0] = Dtk_pnt(1.0, 0.0, 0.0);
561  ControlPoints[1] = Dtk_pnt(1.0, 1.0, 0.0);
562  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
563  curve = Dtk_CurvePtr::DtkDynamicCast(line);
564  entity->SetGeom(curve);
565  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[26]));
566 
567  outArrayTopo[78] = Dtk_EntityPtr::DtkDynamicCast(entity);
568 
569 
570  /*Index 80*/
571  entity = Dtk_Coedge::Create(inDtkBody);
572 
573  entity->SetOrientation(DTK_TRUE);
574 
575  ControlPoints[0] = Dtk_pnt(0.0, 1.0, 0.0);
576  ControlPoints[1] = Dtk_pnt(1.0, 1.0, 0.0);
577  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
578  curve = Dtk_CurvePtr::DtkDynamicCast(line);
579  entity->SetGeom(curve);
580  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[84]));
581 
582  outArrayTopo[80] = Dtk_EntityPtr::DtkDynamicCast(entity);
583 
584 
585  /*Index 86*/
586  entity = Dtk_Coedge::Create(inDtkBody);
587 
588  entity->SetOrientation(DTK_TRUE);
589 
590  ControlPoints[0] = Dtk_pnt(0.0, 1.0, 0.0);
591  ControlPoints[1] = Dtk_pnt(0.0, 0.0, 0.0);
592  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
593  curve = Dtk_CurvePtr::DtkDynamicCast(line);
594  entity->SetGeom(curve);
595  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[88]));
596 
597  outArrayTopo[86] = Dtk_EntityPtr::DtkDynamicCast(entity);
598 
599 
600 
601 
602  /*Into the 4 loop*/
603  /*Index 94*/
604  entity = Dtk_Coedge::Create(inDtkBody);
605 
606  entity->SetOrientation(DTK_TRUE);
607 
608  ControlPoints[0] = Dtk_pnt(0.0, 0.0, 0.0);
609  ControlPoints[1] = Dtk_pnt(0.0, 1.0, 0.0);
610  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
611  curve = Dtk_CurvePtr::DtkDynamicCast(line);
612  entity->SetGeom(curve);
613  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[96]));
614 
615  outArrayTopo[94] = Dtk_EntityPtr::DtkDynamicCast(entity);
616 
617 
618  /*Index 98*/
619  entity = Dtk_Coedge::Create(inDtkBody);
620 
621  entity->SetOrientation(DTK_TRUE);
622 
623  ControlPoints[0] = Dtk_pnt(1.0, 0.0, 0.0);
624  ControlPoints[1] = Dtk_pnt(0.0, 0.0, 0.0);
625  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
626  curve = Dtk_CurvePtr::DtkDynamicCast(line);
627  entity->SetGeom(curve);
628  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[52]));
629 
630  outArrayTopo[98] = Dtk_EntityPtr::DtkDynamicCast(entity);
631 
632 
633  /*Index 100*/
634  entity = Dtk_Coedge::Create(inDtkBody);
635 
636  entity->SetOrientation(DTK_TRUE);
637 
638  ControlPoints[0] = Dtk_pnt(1.0, 1.0, 0.0);
639  ControlPoints[1] = Dtk_pnt(1.0, 0.0, 0.0);
640  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
641  curve = Dtk_CurvePtr::DtkDynamicCast(line);
642  entity->SetGeom(curve);
643  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[70]));
644 
645  outArrayTopo[100] = Dtk_EntityPtr::DtkDynamicCast(entity);
646 
647 
648  /*Index 102*/
649  entity = Dtk_Coedge::Create(inDtkBody);
650 
651  entity->SetOrientation(DTK_TRUE);
652 
653  ControlPoints[0] = Dtk_pnt(0.0, 1.0, 0.0);
654  ControlPoints[1] = Dtk_pnt(1.0, 1.0, 0.0);
655  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
656  curve = Dtk_CurvePtr::DtkDynamicCast(line);
657  entity->SetGeom(curve);
658  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[88]));
659 
660  outArrayTopo[102] = Dtk_EntityPtr::DtkDynamicCast(entity);
661 
662 
663 
664 
665  /*Into the 5 loop*/
666  /*Index 108*/
667  entity = Dtk_Coedge::Create(inDtkBody);
668 
669  entity->SetOrientation(DTK_TRUE);
670 
671  ControlPoints[0] = Dtk_pnt(1.0, 0.0, 0.0);
672  ControlPoints[1] = Dtk_pnt(1.0, 1.0, 0.0);
673  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
674  curve = Dtk_CurvePtr::DtkDynamicCast(line);
675  entity->SetGeom(curve);
676  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[96]));
677 
678  outArrayTopo[108] = Dtk_EntityPtr::DtkDynamicCast(entity);
679 
680 
681  /*Index 110*/
682  entity = Dtk_Coedge::Create(inDtkBody);
683 
684  entity->SetOrientation(DTK_TRUE);
685 
686  ControlPoints[0] = Dtk_pnt(1.0, 1.0, 0.0);
687  ControlPoints[1] = Dtk_pnt(0.0, 1.0, 0.0);
688  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
689  curve = Dtk_CurvePtr::DtkDynamicCast(line);
690  entity->SetGeom(curve);
691  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[84]));
692 
693  outArrayTopo[110] = Dtk_EntityPtr::DtkDynamicCast(entity);
694 
695 
696  /*Index 112*/
697  entity = Dtk_Coedge::Create(inDtkBody);
698 
699  entity->SetOrientation(DTK_TRUE);
700 
701  ControlPoints[0] = Dtk_pnt(0.0, 1.0, 0.0);
702  ControlPoints[1] = Dtk_pnt(0.0, 0.0, 0.0);
703  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
704  curve = Dtk_CurvePtr::DtkDynamicCast(line);
705  entity->SetGeom(curve);
706  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[20]));
707 
708  outArrayTopo[112] = Dtk_EntityPtr::DtkDynamicCast(entity);
709 
710 
711  /*Index 114*/
712  entity = Dtk_Coedge::Create(inDtkBody);
713 
714  entity->SetOrientation(DTK_TRUE);
715 
716  ControlPoints[0] = Dtk_pnt(1.0, 0.0, 0.0);
717  ControlPoints[1] = Dtk_pnt(0.0, 0.0, 0.0);
718  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
719  curve = Dtk_CurvePtr::DtkDynamicCast(line);
720  entity->SetGeom(curve);
721  entity->SetEdge(Dtk_EdgePtr::DtkDynamicCast(outArrayTopo[40]));
722 
723  outArrayTopo[114] = Dtk_EntityPtr::DtkDynamicCast(entity);
724 
725 
726  }

◆ CreateTopoEdge()

void sampleWriter::CreateTopoEdge ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
157  {
158  Dtk_EdgePtr entity = NULL;
159  Dtk_LinePtr line = NULL;
160  Dtk_CurvePtr curve = NULL;
161  Dtk_tab<Dtk_pnt> ControlPoints;
162  Dtk_VertexPtr start_vertex = NULL, end_vertex = NULL;
163 
164  /*nurbs with 2 ControlPoints*/
165  ControlPoints.resize( 2 );
166 
167  /*Index 14 - Edge_AB*/
168  entity = Dtk_Edge::Create( inDtkBody );
169  entity->info() = Dtk_Info::create();
170  entity->info()->SetName( L"Edge_AB" );
171 
172 
173  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_A ] );
174  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
175  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
176 
177  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_B ] );
178  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
179  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
180 
181  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
182  curve = Dtk_CurvePtr::DtkDynamicCast( line );
183  entity->SetGeom( curve );
184 
185  outArrayTopo[ Edge_AB ] = Dtk_EntityPtr::DtkDynamicCast( entity );
186 
187 
188 
189 
190  /*Index 20 - Edge_CA*/
191  entity = Dtk_Edge::Create( inDtkBody );
192  entity->info() = Dtk_Info::create();
193  entity->info()->SetName( L"Edge_CA" );
194 
195 
196  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_C ] );
197  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
198  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
199 
200  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_A ] );
201  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
202  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
203 
204  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
205  curve = Dtk_CurvePtr::DtkDynamicCast( line );
206  entity->SetGeom( curve );
207 
208  outArrayTopo[ Edge_CA ] = Dtk_EntityPtr::DtkDynamicCast( entity );
209 
210 
211  /*Index 26 - Edge_DC*/
212  entity = Dtk_Edge::Create( inDtkBody );
213  entity->info() = Dtk_Info::create();
214  entity->info()->SetName( L"Edge_DC" );
215 
216 
217  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_D ] );
218  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
219  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
220 
221  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_C ] );
222  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
223  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
224 
225  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
226  curve = Dtk_CurvePtr::DtkDynamicCast( line );
227  entity->SetGeom( curve );
228 
229  outArrayTopo[ Edge_DC ] = Dtk_EntityPtr::DtkDynamicCast( entity );
230 
231 
232 
233  /*Index 30 - Edge_BD*/
234  entity = Dtk_Edge::Create( inDtkBody );
235  entity->info() = Dtk_Info::create();
236  entity->info()->SetName( L"Edge_BD" );
237 
238 
239  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_B ] );
240  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
241  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
242 
243  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_D ] );
244  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
245  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
246 
247  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
248  curve = Dtk_CurvePtr::DtkDynamicCast( line );
249  entity->SetGeom( curve );
250 
251  outArrayTopo[ Edge_BD ] = Dtk_EntityPtr::DtkDynamicCast( entity );
252 
253 
254 
255 
256  /*Index 40 - Edge_EA*/
257  entity = Dtk_Edge::Create( inDtkBody );
258  entity->info() = Dtk_Info::create();
259  entity->info()->SetName( L"Edge_EA" );
260 
261 
262  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_E ] );
263  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
264  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
265 
266  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_A ] );
267  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
268  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
269 
270  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
271  curve = Dtk_CurvePtr::DtkDynamicCast( line );
272  entity->SetGeom( curve );
273 
274  outArrayTopo[ Edge_EA ] = Dtk_EntityPtr::DtkDynamicCast( entity );
275 
276 
277 
278  /*Index 48 - Edge_FB*/
279  entity = Dtk_Edge::Create( inDtkBody );
280  entity->info() = Dtk_Info::create();
281  entity->info()->SetName( L"Edge_FB" );
282 
283 
284  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_F ] );
285  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
286  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
287 
288  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_B ] );
289  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
290  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
291 
292  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
293  curve = Dtk_CurvePtr::DtkDynamicCast( line );
294  entity->SetGeom( curve );
295 
296  outArrayTopo[ Edge_FB ] = Dtk_EntityPtr::DtkDynamicCast( entity );
297 
298 
299  /*Index 52 - Edge_FE*/
300  entity = Dtk_Edge::Create( inDtkBody );
301  entity->info() = Dtk_Info::create();
302  entity->info()->SetName( L"Edge_FE" );
303 
304  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_F ] );
305  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
306  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
307 
308  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_E ] );
309  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
310  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
311 
312  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
313  curve = Dtk_CurvePtr::DtkDynamicCast( line );
314  entity->SetGeom( curve );
315 
316  outArrayTopo[ Edge_FE ] = Dtk_EntityPtr::DtkDynamicCast( entity );
317 
318 
319  /*Index 66 - Edge_GD*/
320  entity = Dtk_Edge::Create( inDtkBody );
321  entity->info() = Dtk_Info::create();
322  entity->info()->SetName( L"Edge_GD" );
323 
324 
325  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_G ] );
326  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
327  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
328 
329  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_D ] );
330  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
331  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
332 
333  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
334  curve = Dtk_CurvePtr::DtkDynamicCast( line );
335  entity->SetGeom( curve );
336 
337  outArrayTopo[ Edge_GD ] = Dtk_EntityPtr::DtkDynamicCast( entity );
338 
339 
340  /*Index 70 - Edge_GF*/
341  entity = Dtk_Edge::Create( inDtkBody );
342  entity->info() = Dtk_Info::create();
343  entity->info()->SetName( L"Edge_GF" );
344 
345 
346  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_G ] );
347  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
348  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
349 
350  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_F ] );
351  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
352  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
353 
354  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
355  curve = Dtk_CurvePtr::DtkDynamicCast( line );
356  entity->SetGeom( curve );
357 
358  outArrayTopo[ Edge_GF ] = Dtk_EntityPtr::DtkDynamicCast( entity );
359 
360 
361  /*Index 84 - Edge_HC*/
362  entity = Dtk_Edge::Create( inDtkBody );
363  entity->info() = Dtk_Info::create();
364  entity->info()->SetName( L"Edge_HC" );
365 
366 
367  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_H ] );
368  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
369  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
370 
371  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_C ] );
372  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
373  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
374 
375  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
376  curve = Dtk_CurvePtr::DtkDynamicCast( line );
377  entity->SetGeom( curve );
378 
379  outArrayTopo[ Edge_HC ] = Dtk_EntityPtr::DtkDynamicCast( entity );
380 
381 
382 
383  /*Index 88 - Edge_HG*/
384  entity = Dtk_Edge::Create( inDtkBody );
385  entity->info() = Dtk_Info::create();
386  entity->info()->SetName( L"Edge_HG" );
387 
388 
389  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_H ] );
390  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
391  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
392 
393  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_G ] );
394  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
395  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
396 
397  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
398  curve = Dtk_CurvePtr::DtkDynamicCast( line );
399  entity->SetGeom( curve );
400 
401  outArrayTopo[ Edge_HG ] = Dtk_EntityPtr::DtkDynamicCast( entity );
402 
403 
404  /*Index 96 - Edge_EH*/
405  entity = Dtk_Edge::Create( inDtkBody );
406  entity->info() = Dtk_Info::create();
407  entity->info()->SetName( L"Edge_EH" );
408 
409 
410  start_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_E ] );
411  start_vertex->GetGeom()->GetCoordinates( ControlPoints[ 0 ] );
412  entity->SetStartVertex( Dtk_VertexPtr::DtkDynamicCast( start_vertex ) );
413 
414  end_vertex = Dtk_VertexPtr::DtkDynamicCast( outArrayTopo[ Vertex_H ] );
415  end_vertex->GetGeom()->GetCoordinates( ControlPoints[ 1 ] );
416  entity->SetEndVertex( Dtk_VertexPtr::DtkDynamicCast( end_vertex ) );
417 
418  line = Dtk_Line::Create( ControlPoints[ 0 ], ControlPoints[ 1 ] );
419  curve = Dtk_CurvePtr::DtkDynamicCast( line );
420  entity->SetGeom( curve );
421 
422  outArrayTopo[ Edge_EH ] = Dtk_EntityPtr::DtkDynamicCast( entity );
423 
424  }

◆ CreateTopoEdge_2()

void sampleWriter::CreateTopoEdge_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
103  {
104  Dtk_EdgePtr entity = NULL;
105  Dtk_LinePtr line = NULL;
106  Dtk_CurvePtr curve = NULL;
107  Dtk_tab<Dtk_pnt> ControlPoints;
108  Dtk_VertexPtr start_vertex = NULL, end_vertex = NULL;
109 
110  /*nurbs with 2 ControlPoints*/
111  ControlPoints.resize(2);
112 
113  /*Index 14*/
114  entity = Dtk_Edge::Create(inDtkBody);
115 
116  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[9]);
117  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
118  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
119 
120  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[11]);
121  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
122  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
123 
124  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
125  curve = Dtk_CurvePtr::DtkDynamicCast(line);
126  entity->SetGeom(curve);
127 
128  outArrayTopo[14] = Dtk_EntityPtr::DtkDynamicCast(entity);
129 
130 
131 
132 
133  /*Index 20*/
134  entity = Dtk_Edge::Create(inDtkBody);
135 
136  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[17]);
137  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
138  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
139 
140  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[9]);
141  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
142  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
143 
144  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
145  curve = Dtk_CurvePtr::DtkDynamicCast(line);
146  entity->SetGeom(curve);
147 
148  outArrayTopo[20] = Dtk_EntityPtr::DtkDynamicCast(entity);
149 
150 
151  /*Index 26*/
152  entity = Dtk_Edge::Create(inDtkBody);
153 
154  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[23]);
155  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
156  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
157 
158  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[17]);
159  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
160  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
161 
162  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
163  curve = Dtk_CurvePtr::DtkDynamicCast(line);
164  entity->SetGeom(curve);
165 
166  outArrayTopo[26] = Dtk_EntityPtr::DtkDynamicCast(entity);
167 
168 
169 
170  /*Index 30*/
171  entity = Dtk_Edge::Create(inDtkBody);
172 
173  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[11]);
174  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
175  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
176 
177  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[23]);
178  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
179  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
180 
181  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
182  curve = Dtk_CurvePtr::DtkDynamicCast(line);
183  entity->SetGeom(curve);
184 
185  outArrayTopo[30] = Dtk_EntityPtr::DtkDynamicCast(entity);
186 
187 
188 
189 
190  /*Index 40*/
191  entity = Dtk_Edge::Create(inDtkBody);
192 
193  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[37]);
194  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
195  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
196 
197  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[9]);
198  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
199  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
200 
201  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
202  curve = Dtk_CurvePtr::DtkDynamicCast(line);
203  entity->SetGeom(curve);
204 
205  outArrayTopo[40] = Dtk_EntityPtr::DtkDynamicCast(entity);
206 
207 
208 
209  /*Index 48*/
210  entity = Dtk_Edge::Create(inDtkBody);
211 
212  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[45]);
213  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
214  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
215 
216  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[11]);
217  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
218  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
219 
220  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
221  curve = Dtk_CurvePtr::DtkDynamicCast(line);
222  entity->SetGeom(curve);
223 
224  outArrayTopo[48] = Dtk_EntityPtr::DtkDynamicCast(entity);
225 
226 
227  /*Index 52*/
228  entity = Dtk_Edge::Create(inDtkBody);
229 
230  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[45]);
231  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
232  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
233 
234  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[37]);
235  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
236  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
237 
238  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
239  curve = Dtk_CurvePtr::DtkDynamicCast(line);
240  entity->SetGeom(curve);
241 
242  outArrayTopo[52] = Dtk_EntityPtr::DtkDynamicCast(entity);
243 
244 
245  /*Index 66*/
246  entity = Dtk_Edge::Create(inDtkBody);
247 
248  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[63]);
249  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
250  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
251 
252  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[23]);
253  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
254  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
255 
256  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
257  curve = Dtk_CurvePtr::DtkDynamicCast(line);
258  entity->SetGeom(curve);
259 
260  outArrayTopo[66] = Dtk_EntityPtr::DtkDynamicCast(entity);
261 
262 
263  /*Index 70*/
264  entity = Dtk_Edge::Create(inDtkBody);
265 
266  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[63]);
267  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
268  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
269 
270  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[45]);
271  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
272  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
273 
274  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
275  curve = Dtk_CurvePtr::DtkDynamicCast(line);
276  entity->SetGeom(curve);
277 
278  outArrayTopo[70] = Dtk_EntityPtr::DtkDynamicCast(entity);
279 
280 
281  /*Index 84*/
282  entity = Dtk_Edge::Create(inDtkBody);
283 
284  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[81]);
285  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
286  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
287 
288  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[17]);
289  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
290  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
291 
292  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
293  curve = Dtk_CurvePtr::DtkDynamicCast(line);
294  entity->SetGeom(curve);
295 
296  outArrayTopo[84] = Dtk_EntityPtr::DtkDynamicCast(entity);
297 
298 
299 
300  /*Index 88*/
301  entity = Dtk_Edge::Create(inDtkBody);
302 
303  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[81]);
304  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
305  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
306 
307  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[63]);
308  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
309  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
310 
311  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
312  curve = Dtk_CurvePtr::DtkDynamicCast(line);
313  entity->SetGeom(curve);
314 
315  outArrayTopo[88] = Dtk_EntityPtr::DtkDynamicCast(entity);
316 
317 
318  /*Index 96*/
319  entity = Dtk_Edge::Create(inDtkBody);
320 
321  start_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[37]);
322  start_vertex->GetGeom()->GetCoordinates(ControlPoints[0]);
323  entity->SetStartVertex(Dtk_VertexPtr::DtkDynamicCast(start_vertex));
324 
325  end_vertex = Dtk_VertexPtr::DtkDynamicCast(outArrayTopo[81]);
326  end_vertex->GetGeom()->GetCoordinates(ControlPoints[1]);
327  entity->SetEndVertex(Dtk_VertexPtr::DtkDynamicCast(end_vertex));
328 
329  line = Dtk_Line::Create(ControlPoints[0], ControlPoints[1]);
330  curve = Dtk_CurvePtr::DtkDynamicCast(line);
331  entity->SetGeom(curve);
332 
333  outArrayTopo[96] = Dtk_EntityPtr::DtkDynamicCast(entity);
334 
335  }

◆ CreateTopoFace()

void sampleWriter::CreateTopoFace ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
975  {
976  Dtk_FacePtr entity = NULL;
977  Dtk_NurbsSurfacePtr nurbs_surface = NULL;
978  Dtk_SurfacePtr surface = NULL;
979  Dtk_tab<Dtk_Double64> UKnots;
980  Dtk_tab<Dtk_Double64> VKnots;
981  Dtk_UInt32 UDegree;
982  Dtk_UInt32 VDegree;
983  Dtk_tab<Dtk_tab<Dtk_pnt> > ControlPoints;
984  Dtk_tab<Dtk_tab<Dtk_Double64> > Weights;
985  Dtk_tab<Dtk_UChar8> UKnotsMultiplicities;
986  Dtk_tab<Dtk_UChar8> VKnotsMultiplicities;
987 
988 
989  // Create Nurbs Surface
990  UDegree = 1;
991  UKnots.push_back( 0.0 );
992  UKnots.push_back( 1.0 );
993  UKnotsMultiplicities.push_back( 2 );
994  UKnotsMultiplicities.push_back( 2 );
995 
996  VDegree = 1;
997  VKnots.push_back( 0.0 );
998  VKnots.push_back( 1.0 );
999  VKnotsMultiplicities.push_back( 2 );
1000  VKnotsMultiplicities.push_back( 2 );
1001 
1002 
1003  ControlPoints.resize( 2 );
1004  ControlPoints[ 0 ].resize( 2 );
1005  ControlPoints[ 1 ].resize( 2 );
1006  Weights.resize( 2 );
1007  Weights[ 0 ].resize( 2 );
1008  Weights[ 1 ].resize( 2 );
1009 
1010  Weights[ 0 ][ 0 ] = 1.0;
1011  Weights[ 0 ][ 1 ] = 1.0;
1012  Weights[ 1 ][ 0 ] = 1.0;
1013  Weights[ 1 ][ 1 ] = 1.0;
1014 
1015  /*nurbs with 2 ControlPoints*/
1016  ControlPoints.resize( 2 );
1017 
1018  /*0 Face*/
1019  /*Index 5*/
1020  entity = Dtk_Face::Create( inDtkBody );
1021  entity->info() = Dtk_Info::create();
1022  entity->info()->SetName( L"FaceABCD" );
1023 
1024  entity->AddOuterLoop( Dtk_LoopPtr::DtkDynamicCast( outArrayTopo[ Loop0_ABCD ] ) );
1025 
1026  ControlPoints[ 0 ][ 0 ] = Dtk_pnt( 0.0, 0.0, 100.0 );
1027  ControlPoints[ 0 ][ 1 ] = Dtk_pnt( 0.0, 100.0, 100.0 );
1028  ControlPoints[ 1 ][ 0 ] = Dtk_pnt( 100.0, 0.0, 100.0 );
1029  ControlPoints[ 1 ][ 1 ] = Dtk_pnt( 100.0, 100.0, 100.0 );
1030 
1031 
1032  nurbs_surface = Dtk_NurbsSurface::Create( UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights );
1033  surface = Dtk_SurfacePtr::DtkDynamicCast( nurbs_surface );
1034  entity->SetGeom( surface );
1035 
1036  entity->info() = Dtk_Info::create();
1037  entity->info()->SetId( 200 );
1038  entity->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
1039 
1040  outArrayTopo[ FaceABCD ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1041 
1042  /*Index 33*/
1043  entity = Dtk_Face::Create( inDtkBody );
1044  entity->info() = Dtk_Info::create();
1045  entity->info()->SetName( L"FaceABFE" );
1046 
1047  entity->AddOuterLoop( Dtk_LoopPtr::DtkDynamicCast( outArrayTopo[ Loop1_ABFE ] ) );
1048 
1049  ControlPoints[ 0 ][ 0 ] = Dtk_pnt( 0.0, 0.0, 100.0 );
1050  ControlPoints[ 0 ][ 1 ] = Dtk_pnt( 100.0, 0.0, 100.0 );
1051  ControlPoints[ 1 ][ 0 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
1052  ControlPoints[ 1 ][ 1 ] = Dtk_pnt( 100.0, 0.0, 0.0 );
1053 
1054 
1055 
1056  nurbs_surface = Dtk_NurbsSurface::Create( UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights );
1057  surface = Dtk_SurfacePtr::DtkDynamicCast( nurbs_surface );
1058  entity->SetGeom( surface );
1059 
1060  entity->info() = Dtk_Info::create();
1061  entity->info()->SetId( 201 );
1062  entity->info()->SetColor( Dtk_RGB( 0, 255, 0 ) );
1063 
1064  outArrayTopo[ FaceABFE ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1065 
1066 
1067  /*Index 55*/
1068  entity = Dtk_Face::Create( inDtkBody );
1069  entity->info() = Dtk_Info::create();
1070  entity->info()->SetName( L"FaceFBDG" );
1071 
1072  entity->AddOuterLoop( Dtk_LoopPtr::DtkDynamicCast( outArrayTopo[ Loop2_FBDG ] ) );
1073 
1074  ControlPoints[ 0 ][ 0 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
1075  ControlPoints[ 0 ][ 1 ] = Dtk_pnt( 0.0, 100.0, 0.0 );
1076  ControlPoints[ 1 ][ 0 ] = Dtk_pnt( 0.0, 0.0, 100.0 );
1077  ControlPoints[ 1 ][ 1 ] = Dtk_pnt( 0.0, 100.0, 100.0 );
1078 
1079 
1080 
1081  nurbs_surface = Dtk_NurbsSurface::Create( UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights );
1082  surface = Dtk_SurfacePtr::DtkDynamicCast( nurbs_surface );
1083  entity->SetGeom( surface );
1084 
1085  entity->info() = Dtk_Info::create();
1086  entity->info()->SetId( 202 );
1087  entity->info()->SetColor( Dtk_RGB( 0, 0, 255 ) );
1088 
1089  outArrayTopo[ FaceFBDG ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1090 
1091 
1092 
1093  /*Index 73*/
1094  entity = Dtk_Face::Create( inDtkBody );
1095  entity->info() = Dtk_Info::create();
1096  entity->info()->SetName( L"FaceGDCH" );
1097 
1098  entity->AddOuterLoop( Dtk_LoopPtr::DtkDynamicCast( outArrayTopo[ Loop3_GDCH ] ) );
1099 
1100  ControlPoints[ 0 ][ 0 ] = Dtk_pnt( 0.0, 100.0, 0.0 );
1101  ControlPoints[ 0 ][ 1 ] = Dtk_pnt( 100.0, 100.0, 0.0 );
1102  ControlPoints[ 1 ][ 0 ] = Dtk_pnt( 0.0, 100.0, 100.0 );
1103  ControlPoints[ 1 ][ 1 ] = Dtk_pnt( 100.0, 100.0, 100.0 );
1104 
1105 
1106 
1107  nurbs_surface = Dtk_NurbsSurface::Create( UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights );
1108  surface = Dtk_SurfacePtr::DtkDynamicCast( nurbs_surface );
1109  entity->SetGeom( surface );
1110 
1111  entity->info() = Dtk_Info::create();
1112  entity->info()->SetId( 203 );
1113  entity->info()->SetColor( Dtk_RGB( 0, 255, 255 ) );
1114 
1115  outArrayTopo[ FaceGDCH ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1116 
1117 
1118  /*Index 91*/
1119  entity = Dtk_Face::Create( inDtkBody );
1120  entity->info() = Dtk_Info::create();
1121  entity->info()->SetName( L"FaceEFGH" );
1122 
1123  entity->AddOuterLoop( Dtk_LoopPtr::DtkDynamicCast( outArrayTopo[ Loop4_EFGH ] ) );
1124 
1125  ControlPoints[ 0 ][ 0 ] = Dtk_pnt( 100.0, 0.0, 0.0 );
1126  ControlPoints[ 0 ][ 1 ] = Dtk_pnt( 100.0, 100.0, 0.0 );
1127  ControlPoints[ 1 ][ 0 ] = Dtk_pnt( 0.0, 0.0, 0.0 );
1128  ControlPoints[ 1 ][ 1 ] = Dtk_pnt( 0.0, 100.0, 0.0 );
1129 
1130 
1131 
1132  nurbs_surface = Dtk_NurbsSurface::Create( UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights );
1133  surface = Dtk_SurfacePtr::DtkDynamicCast( nurbs_surface );
1134  entity->SetGeom( surface );
1135 
1136  entity->info() = Dtk_Info::create();
1137  entity->info()->SetId( 204 );
1138  entity->info()->SetColor( Dtk_RGB( 255, 255, 0 ) );
1139 
1140  outArrayTopo[ FaceEFGH ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1141 
1142 
1143 
1144  /*Index 105*/
1145  entity = Dtk_Face::Create( inDtkBody );
1146  entity->info() = Dtk_Info::create();
1147  entity->info()->SetName( L"FaceEHCA" );
1148 
1149  entity->AddOuterLoop( Dtk_LoopPtr::DtkDynamicCast( outArrayTopo[ Loop5_EHCA ] ) );
1150 
1151  ControlPoints[ 0 ][ 0 ] = Dtk_pnt( 100.0, 0.0, 100.0 );
1152  ControlPoints[ 0 ][ 1 ] = Dtk_pnt( 100.0, 100.0, 100.0 );
1153  ControlPoints[ 1 ][ 0 ] = Dtk_pnt( 100.0, 0.0, 0.0 );
1154  ControlPoints[ 1 ][ 1 ] = Dtk_pnt( 100.0, 100.0, 0.0 );
1155 
1156  nurbs_surface = Dtk_NurbsSurface::Create( UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights );
1157  surface = Dtk_SurfacePtr::DtkDynamicCast( nurbs_surface );
1158  entity->SetGeom( surface );
1159 
1160  entity->info() = Dtk_Info::create();
1161  entity->info()->SetId( 205 );
1162 
1163  outArrayTopo[ FaceEHCA ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1164 
1165  }

◆ CreateTopoFace_2()

void sampleWriter::CreateTopoFace_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
823  {
824  Dtk_FacePtr entity = NULL;
825  Dtk_NurbsSurfacePtr nurbs_surface = NULL;
826  Dtk_SurfacePtr surface = NULL;
827  Dtk_tab<Dtk_Double64> UKnots;
828  Dtk_tab<Dtk_Double64> VKnots;
829  Dtk_UInt32 UDegree;
830  Dtk_UInt32 VDegree;
831  Dtk_tab<Dtk_tab<Dtk_pnt> > ControlPoints;
832  Dtk_tab<Dtk_tab<Dtk_Double64> > Weights;
833  Dtk_tab<Dtk_UChar8> UKnotsMultiplicities;
834  Dtk_tab<Dtk_UChar8> VKnotsMultiplicities;
835 
836 
837  // Create Nurbs Surface
838  UDegree = 1;
839  UKnots.push_back(0.0);
840  UKnots.push_back(1.0);
841  UKnotsMultiplicities.push_back(2);
842  UKnotsMultiplicities.push_back(2);
843 
844  VDegree = 1;
845  VKnots.push_back(0.0);
846  VKnots.push_back(1.0);
847  VKnotsMultiplicities.push_back(2);
848  VKnotsMultiplicities.push_back(2);
849 
850 
851  ControlPoints.resize(2);
852  ControlPoints[0].resize(2);
853  ControlPoints[1].resize(2);
854  Weights.resize(2);
855  Weights[0].resize(2);
856  Weights[1].resize(2);
857 
858  Weights[0][0] = 1.0;
859  Weights[0][1] = 1.0;
860  Weights[1][0] = 1.0;
861  Weights[1][1] = 1.0;
862 
863  /*nurbs with 2 ControlPoints*/
864  ControlPoints.resize(2);
865 
866  /*0 Face*/
867  /*Index 5*/
868  entity = Dtk_Face::Create(inDtkBody);
869  SetTopoFaceID(entity, 5);
870 
871  entity->AddOuterLoop(Dtk_LoopPtr::DtkDynamicCast(outArrayTopo[7]));
872 
873  ControlPoints[0][0] = Dtk_pnt(0.0, 0.0, 100.0);
874  ControlPoints[0][1] = Dtk_pnt(0.0, 100.0, 100.0);
875  ControlPoints[1][0] = Dtk_pnt(100.0, 0.0, 100.0);
876  ControlPoints[1][1] = Dtk_pnt(100.0, 100.0, 100.0);
877 
878 
879  nurbs_surface = Dtk_NurbsSurface::Create(UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights);
880  surface = Dtk_SurfacePtr::DtkDynamicCast(nurbs_surface);
881  entity->SetGeom(surface);
882 
883  outArrayTopo[5] = Dtk_EntityPtr::DtkDynamicCast(entity);
884 
885  /*Index 33*/
886  entity = Dtk_Face::Create(inDtkBody);
887  SetTopoFaceID(entity, 33);
888 
889  entity->AddOuterLoop(Dtk_LoopPtr::DtkDynamicCast(outArrayTopo[35]));
890 
891  ControlPoints[0][0] = Dtk_pnt(0.0, 0.0, 100.0);
892  ControlPoints[0][1] = Dtk_pnt(100.0, 0.0, 100.0);
893  ControlPoints[1][0] = Dtk_pnt(0.0, 0.0, 0.0);
894  ControlPoints[1][1] = Dtk_pnt(100.0, 0.0, 0.0);
895 
896 
897 
898  nurbs_surface = Dtk_NurbsSurface::Create(UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights);
899  surface = Dtk_SurfacePtr::DtkDynamicCast(nurbs_surface);
900  entity->SetGeom(surface);
901 
902  outArrayTopo[33] = Dtk_EntityPtr::DtkDynamicCast(entity);
903 
904 
905  /*Index 55*/
906  entity = Dtk_Face::Create(inDtkBody);
907  SetTopoFaceID(entity, 55);
908 
909  entity->AddOuterLoop(Dtk_LoopPtr::DtkDynamicCast(outArrayTopo[57]));
910 
911  ControlPoints[0][0] = Dtk_pnt(0.0, 0.0, 0.0);
912  ControlPoints[0][1] = Dtk_pnt(0.0, 100.0, 0.0);
913  ControlPoints[1][0] = Dtk_pnt(0.0, 0.0, 100.0);
914  ControlPoints[1][1] = Dtk_pnt(0.0, 100.0, 100.0);
915 
916 
917 
918  nurbs_surface = Dtk_NurbsSurface::Create(UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights);
919  surface = Dtk_SurfacePtr::DtkDynamicCast(nurbs_surface);
920  entity->SetGeom(surface);
921 
922  outArrayTopo[55] = Dtk_EntityPtr::DtkDynamicCast(entity);
923 
924 
925 
926  /*Index 73*/
927  entity = Dtk_Face::Create(inDtkBody);
928  SetTopoFaceID(entity, 73);
929 
930  entity->AddOuterLoop(Dtk_LoopPtr::DtkDynamicCast(outArrayTopo[75]));
931 
932  ControlPoints[0][0] = Dtk_pnt(0.0, 100.0, 0.0);
933  ControlPoints[0][1] = Dtk_pnt(100.0, 100.0, 0.0);
934  ControlPoints[1][0] = Dtk_pnt(0.0, 100.0, 100.0);
935  ControlPoints[1][1] = Dtk_pnt(100.0, 100.0, 100.0);
936 
937 
938 
939  nurbs_surface = Dtk_NurbsSurface::Create(UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights);
940  surface = Dtk_SurfacePtr::DtkDynamicCast(nurbs_surface);
941  entity->SetGeom(surface);
942 
943  outArrayTopo[73] = Dtk_EntityPtr::DtkDynamicCast(entity);
944 
945 
946  /*Index 91*/
947  entity = Dtk_Face::Create(inDtkBody);
948  SetTopoFaceID(entity, 91);
949 
950  entity->AddOuterLoop(Dtk_LoopPtr::DtkDynamicCast(outArrayTopo[93]));
951 
952  ControlPoints[0][0] = Dtk_pnt(100.0, 0.0, 0.0);
953  ControlPoints[0][1] = Dtk_pnt(100.0, 100.0, 0.0);
954  ControlPoints[1][0] = Dtk_pnt(0.0, 0.0, 0.0);
955  ControlPoints[1][1] = Dtk_pnt(0.0, 100.0, 0.0);
956 
957 
958 
959  nurbs_surface = Dtk_NurbsSurface::Create(UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights);
960  surface = Dtk_SurfacePtr::DtkDynamicCast(nurbs_surface);
961  entity->SetGeom(surface);
962 
963  outArrayTopo[91] = Dtk_EntityPtr::DtkDynamicCast(entity);
964 
965 
966 
967  /*Index 105*/
968  entity = Dtk_Face::Create(inDtkBody);
969  SetTopoFaceID(entity, 105);
970 
971  entity->AddOuterLoop(Dtk_LoopPtr::DtkDynamicCast(outArrayTopo[107]));
972 
973  ControlPoints[0][0] = Dtk_pnt(100.0, 0.0, 100.0);
974  ControlPoints[0][1] = Dtk_pnt(100.0, 100.0, 100.0);
975  ControlPoints[1][0] = Dtk_pnt(100.0, 0.0, 0.0);
976  ControlPoints[1][1] = Dtk_pnt(100.0, 100.0, 0.0);
977 
978  nurbs_surface = Dtk_NurbsSurface::Create(UDegree, VDegree, UKnots, VKnots, UKnotsMultiplicities, VKnotsMultiplicities, ControlPoints, Weights);
979  surface = Dtk_SurfacePtr::DtkDynamicCast(nurbs_surface);
980  entity->SetGeom(surface);
981 
982  outArrayTopo[105] = Dtk_EntityPtr::DtkDynamicCast(entity);
983 
984  // test : properties on a face
985  Dtk_InfoPtr& face_info = entity->info();
986  if (face_info.IsNULL()) face_info = Dtk_Info::create();
987  Dtk_Val valprop_area("Anodize per specification MIL-A-8625, Type I");
988  face_info->AddAttribute("user defined attribute : : Surface Finish", valprop_area);
989 
990  }

◆ CreateTopoLoop()

void sampleWriter::CreateTopoLoop ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
876  {
877  Dtk_LoopPtr entity = NULL;
878  Dtk_NurbsCurvePtr nurbs_curve = NULL;
879  Dtk_CurvePtr curve = NULL;
880  Dtk_tab<Dtk_pnt> ControlPoints;
881  Dtk_CoedgePtr edge = NULL;
882 
883  /*nurbs with 2 ControlPoints*/
884  ControlPoints.resize( 2 );
885 
886  /*Into the 0 Face*/
887  /*Index 7 - Loop0_ABCD*/
888  entity = Dtk_Loop::Create( inDtkBody );
889  entity->info() = Dtk_Info::create();
890  entity->info()->SetName( L"Loop0_ABCD" );
891 
892  entity->SetOuterInfo( DTK_TRUE );
893  entity->SetOrientation( DTK_TRUE );
894  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge0_AB ] ), DTK_FALSE );
895  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge0_CA ] ), DTK_FALSE );
896  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge0_DC ] ), DTK_FALSE );
897  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge0_BD ] ), DTK_FALSE );
898  outArrayTopo[ Loop0_ABCD ] = Dtk_EntityPtr::DtkDynamicCast( entity );
899 
900  /*Into the 1 Face*/
901  /*Index 35 - Loop1_ABFE*/
902  entity = Dtk_Loop::Create( inDtkBody );
903  entity->info() = Dtk_Info::create();
904  entity->info()->SetName( L"Loop1_ABFE" );
905  entity->SetOuterInfo( DTK_TRUE );
906  entity->SetOrientation( DTK_TRUE );
907  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge1_EA ] ), DTK_TRUE );
908  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge1_AB ] ), DTK_TRUE );
909  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge1_FB ] ), DTK_FALSE );
910  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge1_FE ] ), DTK_TRUE );
911  outArrayTopo[ Loop1_ABFE ] = Dtk_EntityPtr::DtkDynamicCast( entity );
912 
913  /*Into the 2 Face*/
914  /*Index 57 - Loop2_FBDG*/
915  entity = Dtk_Loop::Create( inDtkBody );
916  entity->info() = Dtk_Info::create();
917  entity->info()->SetName( L"Loop2_FBDG" );
918  entity->SetOuterInfo( DTK_TRUE );
919  entity->SetOrientation( DTK_TRUE );
920  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge2_FB ] ), DTK_TRUE );
921  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge2_BD ] ), DTK_TRUE );
922  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge2_GD ] ), DTK_FALSE );
923  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge2_GF ] ), DTK_TRUE );
924  outArrayTopo[ Loop2_FBDG ] = Dtk_EntityPtr::DtkDynamicCast( entity );
925 
926 
927  /*Into the 3 Face*/
928  /*Index 75 - Loop3_GDCH*/
929  entity = Dtk_Loop::Create( inDtkBody );
930  entity->info() = Dtk_Info::create();
931  entity->info()->SetName( L"Loop3_GDCH" );
932  entity->SetOuterInfo( DTK_TRUE );
933  entity->SetOrientation( DTK_TRUE );
934  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge3_GD ] ), DTK_TRUE );
935  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge3_DC ] ), DTK_TRUE );
936  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge3_HC ] ), DTK_FALSE );
937  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge3_HG ] ), DTK_TRUE );
938  outArrayTopo[ Loop3_GDCH ] = Dtk_EntityPtr::DtkDynamicCast( entity );
939 
940  /*Into the 4 Face*/
941  /*Index 93 - Loop4_EFGH*/
942  entity = Dtk_Loop::Create( inDtkBody );
943  entity->info() = Dtk_Info::create();
944  entity->info()->SetName( L"Loop4_EFGH" );
945  entity->SetOuterInfo( DTK_TRUE );
946  entity->SetOrientation( DTK_TRUE );
947  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge4_EH ] ), DTK_FALSE );
948  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge4_FE ] ), DTK_FALSE );
949  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge4_GF ] ), DTK_FALSE );
950  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge4_HG ] ), DTK_FALSE );
951  outArrayTopo[ Loop4_EFGH ] = Dtk_EntityPtr::DtkDynamicCast( entity );
952 
953  /*Into the 5 Face*/
954  /*Index 107 - Loop5_EHCA*/
955  entity = Dtk_Loop::Create( inDtkBody );
956  entity->info() = Dtk_Info::create();
957  entity->info()->SetName( L"Loop5_EHCA" );
958  entity->SetOuterInfo( DTK_TRUE );
959  entity->SetOrientation( DTK_TRUE );
960  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge5_EH ] ), DTK_TRUE );
961  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge5_HC ] ), DTK_TRUE );
962  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge5_CA ] ), DTK_TRUE );
963  entity->AddCoedge( Dtk_CoedgePtr::DtkDynamicCast( outArrayTopo[ Coedge5_EA ] ), DTK_FALSE );
964  outArrayTopo[ Loop5_EHCA ] = Dtk_EntityPtr::DtkDynamicCast( entity );
965 
966  }

◆ CreateTopoLoop_2()

void sampleWriter::CreateTopoLoop_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
732  {
733  Dtk_LoopPtr entity = NULL;
734  Dtk_NurbsCurvePtr nurbs_curve = NULL;
735  Dtk_CurvePtr curve = NULL;
736  Dtk_tab<Dtk_pnt> ControlPoints;
737  Dtk_CoedgePtr edge = NULL;
738 
739  /*nurbs with 2 ControlPoints*/
740  ControlPoints.resize(2);
741 
742  /*Into the 0 Face*/
743  /*Index 7*/
744  entity = Dtk_Loop::Create(inDtkBody);
745  entity->SetOuterInfo(DTK_TRUE);
746  entity->SetOrientation(DTK_TRUE);
747  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[8]), DTK_FALSE);
748  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[16]), DTK_FALSE);
749  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[22]), DTK_FALSE);
750  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[28]), DTK_FALSE);
751  outArrayTopo[7] = Dtk_EntityPtr::DtkDynamicCast(entity);
752 
753  /*Into the 1 Face*/
754  /*Index 35*/
755  entity = Dtk_Loop::Create(inDtkBody);
756  entity->SetOuterInfo(DTK_TRUE);
757  entity->SetOrientation(DTK_TRUE);
758  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[36]), DTK_TRUE);
759  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[42]), DTK_TRUE);
760  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[44]), DTK_FALSE);
761  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[50]), DTK_TRUE);
762  outArrayTopo[35] = Dtk_EntityPtr::DtkDynamicCast(entity);
763 
764  /*Into the 2 Face*/
765  /*Index 57*/
766  entity = Dtk_Loop::Create(inDtkBody);
767  entity->SetOuterInfo(DTK_TRUE);
768  entity->SetOrientation(DTK_TRUE);
769  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[58]), DTK_TRUE);
770  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[60]), DTK_TRUE);
771  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[62]), DTK_FALSE);
772  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[68]), DTK_TRUE);
773  outArrayTopo[57] = Dtk_EntityPtr::DtkDynamicCast(entity);
774 
775 
776  /*Into the 3 Face*/
777  /*Index 75*/
778  entity = Dtk_Loop::Create(inDtkBody);
779  entity->SetOuterInfo(DTK_TRUE);
780  entity->SetOrientation(DTK_TRUE);
781  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[76]), DTK_TRUE);
782  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[78]), DTK_TRUE);
783  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[80]), DTK_FALSE);
784  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[86]), DTK_TRUE);
785  outArrayTopo[75] = Dtk_EntityPtr::DtkDynamicCast(entity);
786 
787  /*Into the 4 Face*/
788  /*Index 93*/
789  entity = Dtk_Loop::Create(inDtkBody);
790  entity->SetOuterInfo(DTK_TRUE);
791  entity->SetOrientation(DTK_TRUE);
792  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[94]), DTK_FALSE);
793  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[98]), DTK_FALSE);
794  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[100]), DTK_FALSE);
795  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[102]), DTK_FALSE);
796  outArrayTopo[93] = Dtk_EntityPtr::DtkDynamicCast(entity);
797 
798  /*Into the 5 Face*/
799  /*Index 107*/
800  entity = Dtk_Loop::Create(inDtkBody);
801  entity->SetOuterInfo(DTK_TRUE);
802  entity->SetOrientation(DTK_TRUE);
803  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[108]), DTK_TRUE);
804  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[110]), DTK_TRUE);
805  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[112]), DTK_TRUE);
806  entity->AddCoedge(Dtk_CoedgePtr::DtkDynamicCast(outArrayTopo[114]), DTK_FALSE);
807  outArrayTopo[107] = Dtk_EntityPtr::DtkDynamicCast(entity);
808 
809  }

◆ CreateTopoLump()

void sampleWriter::CreateTopoLump ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
1231  {
1232  Dtk_LumpPtr entity = NULL;
1233 
1234 
1235  /*Index 3*/
1236  entity = Dtk_Lump::Create( inDtkBody );// create the Lump
1237  entity->info() = Dtk_Info::create();
1238  entity->info()->SetName( L"Lump" );
1239 
1240  entity->AddVolume( Dtk_VolumePtr::DtkDynamicCast( outArrayTopo[ Volume ] ) );// add the Volume into the Lump.
1241 
1242  outArrayTopo[ Lump ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1243  }

◆ CreateTopoLump_2()

void sampleWriter::CreateTopoLump_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
1077  {
1078  Dtk_LumpPtr entity = NULL;
1079 
1080 
1081  /*Index 3*/
1082  entity = Dtk_Lump::Create(inDtkBody);// create the Lump
1083  entity->AddVolume(Dtk_VolumePtr::DtkDynamicCast(outArrayTopo[2]));// add the Volume into the Lump.
1084 
1085  outArrayTopo[1] = Dtk_EntityPtr::DtkDynamicCast(entity);
1086  }

◆ CreateTopoShell()

void sampleWriter::CreateTopoShell ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
1173  {
1174  Dtk_ShellPtr entity = NULL;
1175 
1176 
1177  /*Index 3*/
1178  entity = Dtk_Shell::Create( inDtkBody );// create the Shell
1179  entity->info() = Dtk_Info::create();
1180  entity->info()->SetName( L"Shell" );
1181 
1182  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceABCD ] ), DTK_TRUE );// add the Face into the Shell
1183  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceABFE ] ), DTK_TRUE );// add the Face into the Shell
1184  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceFBDG ] ), DTK_TRUE );// add the Face into the Shell
1185  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceGDCH ] ), DTK_TRUE );// add the Face into the Shell
1186  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceEFGH ] ), DTK_TRUE );// add the Face into the Shell
1187  entity->AddFace( Dtk_FacePtr::DtkDynamicCast( outArrayTopo[ FaceEHCA ] ), DTK_TRUE );// add the Face into the Shell
1188 
1189  outArrayTopo[ Shell ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1190  }

◆ CreateTopoShell_2()

void sampleWriter::CreateTopoShell_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
998  {
999  Dtk_ShellPtr entity = NULL;
1000 
1001 
1002  /*Index 3*/
1003  entity = Dtk_Shell::Create(inDtkBody);// create the Shell
1004  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[5]), DTK_TRUE);// add the Face into the Shell
1005  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[33]), DTK_TRUE);// add the Face into the Shell
1006  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[55]), DTK_TRUE);// add the Face into the Shell
1007  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[73]), DTK_TRUE);// add the Face into the Shell
1008  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[91]), DTK_TRUE);// add the Face into the Shell
1009  entity->AddFace(Dtk_FacePtr::DtkDynamicCast(outArrayTopo[105]), DTK_TRUE);// add the Face into the Shell
1010 
1011  /*
1012  Dtk_InfoPtr& shell_info = entity->info();
1013  if (shell_info.IsNULL()) shell_info = Dtk_Info::create();
1014 
1015  Dtk_Val valprop_area("60000 mm2");
1016  shell_info->AddAttribute("geometric validation property : area : surface area measure",valprop_area);
1017  */
1018  outArrayTopo[3] = Dtk_EntityPtr::DtkDynamicCast(entity);
1019  }

◆ CreateTopoVertex()

void sampleWriter::CreateTopoVertex ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
79  {
80  Dtk_VertexPtr entity = NULL;
81  Dtk_PointPtr point = NULL;
82 
83  /*Index 9 - Vertex_A*/
84  entity = Dtk_Vertex::Create( inDtkBody );
85  entity->info() = Dtk_Info::create();
86  entity->info()->SetName( L"Vertex_A" );
87  point = Dtk_Point::Create( Dtk_pnt( 100.0, 0.0, 100.0 ) );
88  entity->SetGeom( point );
89  outArrayTopo[ Vertex_A ] = Dtk_EntityPtr::DtkDynamicCast( entity );
90 
91  /*Index 11 - Vertex_B*/
92  entity = Dtk_Vertex::Create( inDtkBody );
93  entity->info() = Dtk_Info::create();
94  entity->info()->SetName( L"Vertex_B" );
95 
96  point = Dtk_Point::Create( Dtk_pnt( 0.0, 0.0, 100.0 ) );
97  entity->SetGeom( point );
98  outArrayTopo[ Vertex_B ] = Dtk_EntityPtr::DtkDynamicCast( entity );
99 
100  /*Index 17 - Vertex_C */
101  entity = Dtk_Vertex::Create( inDtkBody );
102  entity->info() = Dtk_Info::create();
103  entity->info()->SetName( L"Vertex_C" );
104 
105  point = Dtk_Point::Create( Dtk_pnt( 100.0, 100.0, 100.0 ) );
106  entity->SetGeom( point );
107  outArrayTopo[ Vertex_C ] = Dtk_EntityPtr::DtkDynamicCast( entity );
108 
109  /*Index 23 - Vertex_D*/
110  entity = Dtk_Vertex::Create( inDtkBody );
111  entity->info() = Dtk_Info::create();
112  entity->info()->SetName( L"Vertex_D" );
113 
114  point = Dtk_Point::Create( Dtk_pnt( 0.0, 100.0, 100.0 ) );
115  entity->SetGeom( point );
116  outArrayTopo[ Vertex_D ] = Dtk_EntityPtr::DtkDynamicCast( entity );
117 
118  /*Index 37 - Vertex_E*/
119  entity = Dtk_Vertex::Create( inDtkBody );
120  entity->info() = Dtk_Info::create();
121  entity->info()->SetName( L"Vertex_E" );
122 
123  point = Dtk_Point::Create( Dtk_pnt( 100.0, 0.0, 0.0 ) );
124  entity->SetGeom( point );
125  outArrayTopo[ Vertex_E ] = Dtk_EntityPtr::DtkDynamicCast( entity );
126 
127  /*Index 45 - Vertex_F*/
128  entity = Dtk_Vertex::Create( inDtkBody );
129  entity->info() = Dtk_Info::create();
130  entity->info()->SetName( L"Vertex_F" );
131 
132  point = Dtk_Point::Create( Dtk_pnt( 0.0, 0.0, 0.0 ) );
133  entity->SetGeom( point );
134  outArrayTopo[ Vertex_F ] = Dtk_EntityPtr::DtkDynamicCast( entity );
135 
136  /*Index 63 - Vertex_G*/
137  entity = Dtk_Vertex::Create( inDtkBody );
138  entity->info() = Dtk_Info::create();
139  entity->info()->SetName( L"Vertex_G" );
140 
141  point = Dtk_Point::Create( Dtk_pnt( 0.0, 100.0, 0.0 ) );
142  entity->SetGeom( point );
143  outArrayTopo[ Vertex_G ] = Dtk_EntityPtr::DtkDynamicCast( entity );
144 
145  /*Index 81 - Vertex_H*/
146  entity = Dtk_Vertex::Create( inDtkBody );
147  entity->info() = Dtk_Info::create();
148  entity->info()->SetName( L"Vertex_H" );
149 
150  point = Dtk_Point::Create( Dtk_pnt( 100.0, 100.0, 0.0 ) );
151  entity->SetGeom( point );
152  outArrayTopo[ Vertex_H ] = Dtk_EntityPtr::DtkDynamicCast( entity );
153  }

◆ CreateTopoVertex_2()

void sampleWriter::CreateTopoVertex_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
48  {
49  Dtk_VertexPtr entity = NULL;
50  Dtk_PointPtr point = NULL;
51 
52  /*Index 9*/
53  entity = Dtk_Vertex::Create(inDtkBody);
54  point = Dtk_Point::Create(Dtk_pnt(100.0, 0.0, 100.0));
55  entity->SetGeom(point);
56  outArrayTopo[9] = Dtk_EntityPtr::DtkDynamicCast(entity);
57 
58  /*Index 11*/
59  entity = Dtk_Vertex::Create(inDtkBody);
60  point = Dtk_Point::Create(Dtk_pnt(0.0, 0.0, 100.0));
61  entity->SetGeom(point);
62  outArrayTopo[11] = Dtk_EntityPtr::DtkDynamicCast(entity);
63 
64  /*Index 17*/
65  entity = Dtk_Vertex::Create(inDtkBody);
66  point = Dtk_Point::Create(Dtk_pnt(100.0, 100.0, 100.0));
67  entity->SetGeom(point);
68  outArrayTopo[17] = Dtk_EntityPtr::DtkDynamicCast(entity);
69 
70  /*Index 23*/
71  entity = Dtk_Vertex::Create(inDtkBody);
72  point = Dtk_Point::Create(Dtk_pnt(0.0, 100.0, 100.0));
73  entity->SetGeom(point);
74  outArrayTopo[23] = Dtk_EntityPtr::DtkDynamicCast(entity);
75 
76  /*Index 37*/
77  entity = Dtk_Vertex::Create(inDtkBody);
78  point = Dtk_Point::Create(Dtk_pnt(100.0, 0.0, 0.0));
79  entity->SetGeom(point);
80  outArrayTopo[37] = Dtk_EntityPtr::DtkDynamicCast(entity);
81 
82  /*Index 45*/
83  entity = Dtk_Vertex::Create(inDtkBody);
84  point = Dtk_Point::Create(Dtk_pnt(0.0, 0.0, 0.0));
85  entity->SetGeom(point);
86  outArrayTopo[45] = Dtk_EntityPtr::DtkDynamicCast(entity);
87 
88  /*Index 63*/
89  entity = Dtk_Vertex::Create(inDtkBody);
90  point = Dtk_Point::Create(Dtk_pnt(0.0, 100.0, 0.0));
91  entity->SetGeom(point);
92  outArrayTopo[63] = Dtk_EntityPtr::DtkDynamicCast(entity);
93 
94  /*Index 81*/
95  entity = Dtk_Vertex::Create(inDtkBody);
96  point = Dtk_Point::Create(Dtk_pnt(100.0, 100.0, 0.0));
97  entity->SetGeom(point);
98  outArrayTopo[81] = Dtk_EntityPtr::DtkDynamicCast(entity);
99  }

◆ CreateTopoVolume()

void sampleWriter::CreateTopoVolume ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
1215  {
1216  Dtk_VolumePtr entity = NULL;
1217 
1218 
1219  /*Index 3*/
1220  entity = Dtk_Volume::Create( inDtkBody );// create the Volume
1221  entity->info() = Dtk_Info::create();
1222  entity->info()->SetName( L"Volume" );
1223 
1224  entity->AddOuterShell( Dtk_ShellPtr::DtkDynamicCast( outArrayTopo[ Shell ] ) );// add the Shell into the Volume.
1225 
1226  outArrayTopo[ Volume ] = Dtk_EntityPtr::DtkDynamicCast( entity );
1227  }

◆ CreateTopoVolume_2()

void sampleWriter::CreateTopoVolume_2 ( std::map< Dtk_ID, Dtk_EntityPtr > &  outArrayTopo,
const Dtk_BodyPtr &  inDtkBody 
)
1052  {
1053  Dtk_VolumePtr entity = NULL;
1054 
1055 
1056  /*Index 3*/
1057  entity = Dtk_Volume::Create(inDtkBody);// create the Volume
1058  entity->AddOuterShell(Dtk_ShellPtr::DtkDynamicCast(outArrayTopo[3]));// add the Shell into the Volume.
1059 
1060  // test : properties on a solid : on the Dtk_Volume
1061  Dtk_InfoPtr& volume_info = entity->info();
1062  if (volume_info.IsNULL()) volume_info = Dtk_Info::create();
1063  volume_info->SetId(3);
1064 
1065  Dtk_Val valprop_area("60000 mm2");
1066  volume_info->AddAttribute("geometric validation property : : surface area measure", valprop_area);
1067  Dtk_Val valprop_volume("10000 mm3");
1068  volume_info->AddAttribute("geometric validation property : : volume measure", valprop_volume);
1069  Dtk_Val valprop_CG(Dtk_pnt(50., 50., 50.));
1070  volume_info->AddAttribute("geometric validation property : : centre point", valprop_CG);
1071 
1072  outArrayTopo[2] = Dtk_EntityPtr::DtkDynamicCast(entity);
1073  }

◆ CreateView()

Dtk_ModelDisplayPtr sampleWriter::CreateView ( )

◆ FillFacesColors()

void sampleWriter::FillFacesColors ( Dtk_MeshPtr &  inoutCubeMesh)

Filling mesh faces with colors.

245  {
246  Dtk_InfoPtr infoFace0 = Dtk_Info::create();
247  infoFace0->SetColor( Dtk_RGB( 255, 1, 0 ) );
248  inoutCubeMesh->get_mesh_face( 0 )->info() = infoFace0;
249 
250  Dtk_InfoPtr infoFace1 = Dtk_Info::create();
251  infoFace1->SetColor( Dtk_RGB( 0, 255, 0 ) );
252  inoutCubeMesh->get_mesh_face( 1 )->info() = infoFace1;
253 
254  Dtk_InfoPtr infoFace2 = Dtk_Info::create();
255  infoFace2->SetColor( Dtk_RGB( 0, 0, 255 ) );
256  inoutCubeMesh->get_mesh_face( 2 )->info() = infoFace2;
257 
258  Dtk_InfoPtr infoFace3 = Dtk_Info::create();
259  infoFace3->SetColor( Dtk_RGB( 255, 255, 0 ) );
260  inoutCubeMesh->get_mesh_face( 3 )->info() = infoFace3;
261 
262  Dtk_InfoPtr infoFace4 = Dtk_Info::create();
263  infoFace4->SetColor( Dtk_RGB( 0, 255, 255 ) );
264  inoutCubeMesh->get_mesh_face( 4 )->info() = infoFace4;
265 
266  Dtk_InfoPtr infoFace5 = Dtk_Info::create();
267  infoFace5->SetColor( Dtk_RGB( 255, 128, 0 ) );
268  inoutCubeMesh->get_mesh_face( 5 )->info() = infoFace5;
269  }

◆ FillInfos()

void sampleWriter::FillInfos ( Dtk_InfoPtr &  inf,
Dtk_ID  id,
const Dtk_RGB &  color 
)
1784  {
1785  inf = Dtk_Info::create();
1786  inf->SetId(id);
1787  if (!(color == Dtk_RGB()))
1788  inf->SetColor(color);
1789  }

◆ MakeArc2D()

Dtk_CurvePtr sampleWriter::MakeArc2D ( const Dtk_pnt &  P0,
double  radius,
double  from,
double  to 
)
1719  {
1720  Dtk_EllipsePtr circle = Dtk_Ellipse::Create(P0, Dtk_dir(0, 0, 1), Dtk_dir(1, 0, 0), radius);
1721  circle->SetTrimmingParameters(from, to);
1722  return Dtk_CurvePtr::DtkDynamicCast(circle);
1723  }

◆ MakeCoedge()

Dtk_CoedgePtr sampleWriter::MakeCoedge ( Dtk_BodyPtr &  body,
const Dtk_EdgePtr  edge,
Dtk_bool  sensedgeVScoedge,
const Dtk_CurvePtr &  curve2d 
)
1775  {
1776  Dtk_CoedgePtr coedge = Dtk_Coedge::Create(body);
1777  coedge->SetGeom(curve2d);
1778  coedge->SetEdge(edge);
1779  coedge->SetOrientation(sensedgeVScoedge);
1780  return coedge;
1781  }

◆ MakeCyl()

Dtk_SurfacePtr sampleWriter::MakeCyl ( const Dtk_pnt &  O,
double  radius,
double  height 
)
1737  {
1738  Dtk_CylindricalSurfacePtr cyl = Dtk_CylindricalSurface::Create(O, Dtk_dir(0, 0, 1), Dtk_dir(1, 0, 0), radius);
1739  double domain[4];
1740  domain[0] = 0;
1741  domain[1] = 2 * DTK_PI;
1742  domain[2] = 0;
1743  domain[3] = height;
1744  cyl->SetTrimUVBox(domain);
1745  return Dtk_SurfacePtr::DtkDynamicCast(cyl);
1746  }

◆ MakeEdge()

Dtk_EdgePtr sampleWriter::MakeEdge ( Dtk_BodyPtr &  body,
const Dtk_VertexPtr &  vstart,
const Dtk_VertexPtr &  vend,
const Dtk_CurvePtr &  curve3d,
Dtk_ID  id 
)
1726  {
1727  Dtk_EdgePtr edge = Dtk_Edge::Create(body);
1728  edge->info() = Dtk_Info::create();
1729  edge->info()->SetId(id+10);
1730  edge->SetGeom(curve3d);
1731  edge->SetStartVertex(vstart);
1732  edge->SetEndVertex(vend);
1733  return edge;
1734  }

◆ MakeOuterFace()

Dtk_FacePtr sampleWriter::MakeOuterFace ( Dtk_BodyPtr &  body,
const Dtk_SurfacePtr &  surf,
const Dtk_CoedgePtr &  c0,
const Dtk_CoedgePtr &  c1,
const Dtk_CoedgePtr &  c2,
const Dtk_CoedgePtr &  c3 
)
1762  {
1763  Dtk_FacePtr face = Dtk_Face::Create(body);
1764  face->SetGeom(surf);
1765  Dtk_LoopPtr loop = Dtk_Loop::Create(body);
1766  face->AddLoop(loop, DTK_TRUE);
1767  if (c0.IsNotNULL()) loop->AddCoedge(c0, DTK_TRUE);
1768  if (c1.IsNotNULL()) loop->AddCoedge(c1, DTK_TRUE);
1769  if (c2.IsNotNULL()) loop->AddCoedge(c2, DTK_TRUE);
1770  if (c3.IsNotNULL()) loop->AddCoedge(c3, DTK_TRUE);
1771  return face;
1772  }

◆ MakePlane()

Dtk_SurfacePtr sampleWriter::MakePlane ( const Dtk_pnt &  O,
const Dtk_pnt &  N,
double  trim 
)
1749  {
1750  Dtk_PlaneSurfacePtr plane = Dtk_PlaneSurface::Create(O, N, Dtk_dir(1, 0, 0));
1751  double domain[4];
1752  domain[0] = -trim;
1753  domain[1] = trim;
1754  domain[2] = -trim;
1755  domain[3] = trim;
1756  plane->SetTrimUVBox(domain);
1757  return Dtk_SurfacePtr::DtkDynamicCast(plane);
1758  }

◆ MakeSegment()

Dtk_CurvePtr sampleWriter::MakeSegment ( const Dtk_pnt &  P0,
const Dtk_pnt &  P1 
)
1704  {
1705  Dtk_dir D = P1 - P0;
1706  double nrm = norm(D);
1707  D /= nrm;
1708  Dtk_LinePtr line = Dtk_Line::Create(P0, D);
1709  line->SetTrimmingParameters(0, nrm);
1710  return Dtk_CurvePtr::DtkDynamicCast(line);
1711  }

◆ MakeSegment2D()

Dtk_CurvePtr sampleWriter::MakeSegment2D ( double  xmin,
double  ymin,
double  xmax,
double  ymax 
)
1714  {
1715  return MakeSegment(Dtk_pnt(xmin, ymin, 0), Dtk_pnt(xmax, ymax, 0));
1716  }

◆ MakeVertex()

Dtk_VertexPtr sampleWriter::MakeVertex ( Dtk_BodyPtr &  body,
const Dtk_pnt &  P 
)
1697  {
1698  Dtk_VertexPtr vtx = Dtk_Vertex::Create(body);
1699  vtx->SetGeom(Dtk_Point::Create(P));
1700  return vtx;
1701  }

◆ SetTopoFaceID()

void sampleWriter::SetTopoFaceID ( const Dtk_FacePtr &  face,
const Dtk_ID  id 
)
814  {
815  Dtk_InfoPtr& face_info = face->info();
816  if (face_info.IsNULL()) face_info = Dtk_Info::create();
817  face_info->SetId(id);
818  }
sampleWriter::Coedge0_DC
@ Coedge0_DC
Definition: testcreatecube.cpp:43
sampleWriter::Coedge3_HC
@ Coedge3_HC
Definition: testcreatecube.cpp:57
sampleWriter::CreateTopoVolume
void CreateTopoVolume(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecube.cpp:1214
Dtk_ModelDisplay::Create
static Dtk_ModelDisplayPtr Create(const Dtk_CameraPtr &inCamera, const Dtk_EntityPtr &inClippingEntity, const Dtk_bool inIsActivated)
Full featured constructor.
sampleWriter::Loop5_EHCA
@ Loop5_EHCA
Definition: testcreatecube.cpp:68
Dtk_pair
Definition: util_stl_dtk.hpp:917
DTK_MESH_NORMAL
#define DTK_MESH_NORMAL
Definition: util_mesh_dtk.hpp:31
sampleWriter::Edge_GD
@ Edge_GD
Definition: testcreatecube.cpp:34
Dtk_transfo
This is the Transformation dedicated class.
Definition: dtk_transfo.hpp:19
Dtk_mesh_face
This is a high level face class.
Definition: util_mesh_dtk.hpp:870
Dtk_RGB::SetRGBA
void SetRGBA(const int &inRed, const int &inGreen, const int &inBlue, const int &inAlpha=-1)
Definition: dtk_rgb.hpp:49
Dtk_TextureInfos::Create
static Dtk_TextureInfosPtr Create(const TextureMappingTypeEnum &inType)
Create a Dtk_TextureInfosPtr.
sampleWriter::CreateTopoLoop
void CreateTopoLoop(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecube.cpp:875
sampleWriter::Coedge3_GD
@ Coedge3_GD
Definition: testcreatecube.cpp:53
Dtk_Info::AddAttribute
Dtk_ErrorStatus AddAttribute(Dtk_string name, Dtk_Val val)
Dtk_Float32
float Dtk_Float32
Definition: define.h:700
Dtk_PlaneSurface::Create
static Dtk_PlaneSurfacePtr Create(const Dtk_pnt &inOrigin, const Dtk_dir &inNormal, const Dtk_dir &inUDirection, const Dtk_dir &inVDirection=Dtk_dir())
Create an infinite plane surface.
sampleWriter::Vertex_A
@ Vertex_A
Definition: testcreatecube.cpp:19
Dtk_Info::SetName
Dtk_ErrorStatus SetName(Dtk_string inName)
sampleWriter::CreateTopoVertex
void CreateTopoVertex(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecube.cpp:78
sampleWriter::Edge_FB
@ Edge_FB
Definition: testcreatecube.cpp:32
sampleWriter::CreateMeshCube
Dtk_MeshPtr CreateMeshCube()
Mesh Cube sample.
Definition: testcreatemesh.cpp:207
Dtk_TextStyle
This is the text_style. This class gathers several informations about text style.
Definition: util_draw_dtk.hpp:260
sampleWriter::CreateTopoFace
void CreateTopoFace(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecube.cpp:974
sampleWriter::MakeCoedge
Dtk_CoedgePtr MakeCoedge(Dtk_BodyPtr &body, const Dtk_EdgePtr edge, Dtk_bool sensedgeVScoedge, const Dtk_CurvePtr &curve2d)
Definition: testcreatecube.cpp:1774
sampleWriter::Coedge5_CA
@ Coedge5_CA
Definition: testcreatecube.cpp:42
Dtk_SmartPtr::IsNotNULL
Dtk_bool IsNotNULL() const
Definition: util_ptr_dtk.hpp:119
Dtk_transfo::setOrigin
void setOrigin(const Dtk_pnt &O)
Set a new O center point.
Dtk_transfo::setZdir
void setZdir(const Dtk_dir &Z)
Set a new Z vector.
sampleWriter::Shell
@ Shell
Definition: testcreatecube.cpp:18
sampleWriter::Edge_FE
@ Edge_FE
Definition: testcreatecube.cpp:33
Dtk_Loop::Create
static Dtk_LoopPtr Create(const Dtk_BodyPtr &inParentBody)
Create a loop in a body.
sampleWriter::Coedge4_HG
@ Coedge4_HG
Definition: testcreatecube.cpp:60
sampleWriter::Coedge5_EH
@ Coedge5_EH
Definition: testcreatecube.cpp:62
DTK_TRUE
#define DTK_TRUE
Definition: define.h:727
sampleWriter::CreateTopoVolume_2
void CreateTopoVolume_2(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecylfdt.cpp:1051
dtk_text_type_value
@ dtk_text_type_value
Definition: str_def.h:14
Dtk_UInt32
uint32_t Dtk_UInt32
Definition: define.h:688
Dtk_string
This is a high level string class.
Definition: dtk_string.hpp:58
Dtk_Size_t
size_t Dtk_Size_t
Definition: define.h:712
sampleWriter::Volume
@ Volume
Definition: testcreatecube.cpp:17
sampleWriter::SetTopoFaceID
void SetTopoFaceID(const Dtk_FacePtr &face, const Dtk_ID id)
Definition: testcreatecylfdt.cpp:813
sampleWriter::Coedge4_GF
@ Coedge4_GF
Definition: testcreatecube.cpp:56
Dtk_mesh_face::add_triangle_strip
int add_triangle_strip(const Dtk_tab< Dtk_UInt32 > *inIndices)
Add one triangle strip.
sampleWriter::Edge_BD
@ Edge_BD
Definition: testcreatecube.cpp:30
sampleWriter::CreateTopoLump
void CreateTopoLump(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecube.cpp:1230
Dtk_Text
This is the base text class. It's part of Dtk_CompositeText. It's used into a lot of 2D Entities It c...
Definition: util_draw_dtk.hpp:1126
sampleWriter::Edge_HC
@ Edge_HC
Definition: testcreatecube.cpp:36
Dtk_RenderInfos::Create
static Dtk_RenderInfosPtr Create(const Dtk_string &inName)
Create a Dtk_RenderInfosPtr.
Dtk_AxisSystem::create
static Dtk_SmartPtr< Dtk_AxisSystem > create()
Dtk_Info::SetMetaData
Dtk_ErrorStatus SetMetaData(Dtk_tab< Dtk_MetaDataPtr > &inArray)
sampleWriter::Coedge5_EA
@ Coedge5_EA
Definition: testcreatecube.cpp:48
sampleWriter::Coedge3_HG
@ Coedge3_HG
Definition: testcreatecube.cpp:59
Dtk_Body::Create
static Dtk_BodyPtr Create()
Create a body.
DTK_MESH_XYZ
#define DTK_MESH_XYZ
Definition: util_mesh_dtk.hpp:30
Dtk_LightMap::Create
static Dtk_LightMapPtr Create(Dtk_RGB inAmbiant, Dtk_RGB inDiffuse, Dtk_RGB inSpecular)
Create a Dtk_LightMapPtr.
DTK_FALSE
#define DTK_FALSE
Definition: define.h:728
sampleWriter::Edge_CA
@ Edge_CA
Definition: testcreatecube.cpp:28
sampleWriter::Coedge0_BD
@ Coedge0_BD
Definition: testcreatecube.cpp:45
Dtk_bool
char Dtk_bool
Definition: define.h:725
Dtk_TextStyle::Slant
Dtk_Double64 & Slant()
Retrieves the text slant - get/set -.
Dtk_mesh::add_vertex
int add_vertex(const Dtk_pnt *inVertex, const Dtk_dir *inNormal=NULL, const Dtk_RGB *inColor=NULL, Dtk_Float32 inU=0., Dtk_Float32 inV=0., Dtk_Float32 inUBrep=0., Dtk_Float32 inVBrep=0.)
Add a vertex to the mesh vertices list.
Dtk_RenderInfos::SetTexture
void SetTexture(const Dtk_TextureInfosPtr &inTexture)
Set Dtk_Texture.
Dtk_Ellipse::Create
static Dtk_EllipsePtr Create(const Dtk_Ellipse &inEllipseToCopy)
Dtk_Symbol::Create
static Dtk_SymbolPtr Create()
Base constructor.
DTK_MESH_UV_TEXTURES
#define DTK_MESH_UV_TEXTURES
Definition: util_mesh_dtk.hpp:33
DTK_ANCHOR_MIDDLE_CENTER
@ DTK_ANCHOR_MIDDLE_CENTER
Definition: util_draw_dtk.hpp:104
sampleWriter::Coedge2_GF
@ Coedge2_GF
Definition: testcreatecube.cpp:55
sampleWriter::Edge_EH
@ Edge_EH
Definition: testcreatecube.cpp:38
Dtk_Double64
double Dtk_Double64
Definition: define.h:699
sampleWriter::Vertex_H
@ Vertex_H
Definition: testcreatecube.cpp:26
Dtk_transfo::setXdir
void setXdir(const Dtk_dir &X)
Set a new X vector.
sampleWriter::CreateTopoCoEdge
void CreateTopoCoEdge(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecube.cpp:428
sampleWriter::Coedge2_FB
@ Coedge2_FB
Definition: testcreatecube.cpp:50
Dtk_mesh
This is a high level mesh class.
Definition: util_mesh_dtk.hpp:485
Dtk_Dimension::DistanceDimension
@ DistanceDimension
Definition: util_draw_dtk.hpp:4875
Dtk_pair::first
T1 first
Definition: util_stl_dtk.hpp:919
Dtk_TextStyle::CharWidth
Dtk_Double64 & CharWidth()
Retrieves the char width - get/set -.
sampleWriter::FaceABCD
@ FaceABCD
Definition: testcreatecube.cpp:69
Dtk_Val
Definition: dtk_val.hpp:67
Dtk_mesh_face::add_subinfo
int add_subinfo(Dtk_InfoPtr &ininf)
sampleWriter::MakeSegment
Dtk_CurvePtr MakeSegment(const Dtk_pnt &P0, const Dtk_pnt &P1)
Definition: testcreatecube.cpp:1703
Dtk_Face::Create
static Dtk_FacePtr Create(const Dtk_BodyPtr &inParentBody)
Create a face in a body.
sampleWriter::Vertex_G
@ Vertex_G
Definition: testcreatecube.cpp:25
sampleWriter::Coedge4_FE
@ Coedge4_FE
Definition: testcreatecube.cpp:54
DTK_MESH_RGB
#define DTK_MESH_RGB
Definition: util_mesh_dtk.hpp:32
DTK_DASHED
@ DTK_DASHED
Definition: util_ent_dtk.hpp:48
sampleWriter::Loop0_ABCD
@ Loop0_ABCD
Definition: testcreatecube.cpp:63
sampleWriter::FaceABFE
@ FaceABFE
Definition: testcreatecube.cpp:70
sampleWriter::FaceGDCH
@ FaceGDCH
Definition: testcreatecube.cpp:72
sampleWriter::Coedge3_DC
@ Coedge3_DC
Definition: testcreatecube.cpp:44
sampleWriter::CreateTopoEdge_2
void CreateTopoEdge_2(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecylfdt.cpp:102
sampleWriter::Vertex_B
@ Vertex_B
Definition: testcreatecube.cpp:20
sampleWriter::FaceEFGH
@ FaceEFGH
Definition: testcreatecube.cpp:73
sampleWriter::CreateTopoLoop_2
void CreateTopoLoop_2(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecylfdt.cpp:731
Dtk_Line::Create
static Dtk_LinePtr Create(const Dtk_Line &inLineToCopy)
constructors returning Smart pointers
sampleWriter::CreateTopoShell
void CreateTopoShell(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecube.cpp:1172
sampleWriter::Edge_EA
@ Edge_EA
Definition: testcreatecube.cpp:31
sampleWriter::MakeOuterFace
Dtk_FacePtr MakeOuterFace(Dtk_BodyPtr &body, const Dtk_SurfacePtr &surf, const Dtk_CoedgePtr &c0, const Dtk_CoedgePtr &c1, const Dtk_CoedgePtr &c2, const Dtk_CoedgePtr &c3)
Definition: testcreatecube.cpp:1760
sampleWriter::Edge_AB
@ Edge_AB
Definition: testcreatecube.cpp:27
Dtk_anchor_type
Dtk_anchor_type
Definition: util_draw_dtk.hpp:99
sampleWriter::Edge_GF
@ Edge_GF
Definition: testcreatecube.cpp:35
DTK_Text_type
DTK_Text_type
Definition: str_def.h:11
Dtk_Int32
int32_t Dtk_Int32
Definition: define.h:687
Dtk_tab::resize
void resize(Dtk_Size_t n, const T &t)
Resizes the array.
Definition: util_stl_dtk.hpp:603
sampleWriter::CreateTopoCoEdge_2
void CreateTopoCoEdge_2(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecylfdt.cpp:340
DTK_DOTTED
@ DTK_DOTTED
Definition: util_ent_dtk.hpp:54
Dtk_Symbol::TypeDatum
@ TypeDatum
Definition: util_draw_dtk.hpp:6510
sampleWriter::Coedge2_GD
@ Coedge2_GD
Definition: testcreatecube.cpp:52
sampleWriter::Loop1_ABFE
@ Loop1_ABFE
Definition: testcreatecube.cpp:64
Dtk_Dimension::Create
static Dtk_DimensionPtr Create()
Base constructor.
Dtk_MetaData::TypeProperty
@ TypeProperty
Definition: dtk_metadata.hpp:28
Dtk_Dimension::DimensionTypeEnum
DimensionTypeEnum
Definition: util_draw_dtk.hpp:4855
Dtk_Lump::Create
static Dtk_LumpPtr Create(const Dtk_BodyPtr &inParentBody)
Create a lump in a body.
sampleWriter::Vertex_D
@ Vertex_D
Definition: testcreatecube.cpp:22
sampleWriter::CreateTopoFace_2
void CreateTopoFace_2(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecylfdt.cpp:822
Dtk_mesh_face::add_point
int add_point(Dtk_UInt32 inpnt)
Dtk_pair::second
T2 second
Definition: util_stl_dtk.hpp:920
Dtk_SmartPtr::DtkDynamicCast
static Dtk_SmartPtr< T > DtkDynamicCast(const Dtk_SmartPtr< T2 > &p)
Definition: util_ptr_dtk.hpp:101
Dtk_mesh::set_mesh_color
void set_mesh_color(const Dtk_RGB &inColor)
set color in Dtk_mesh
sampleWriter::Coedge1_FB
@ Coedge1_FB
Definition: testcreatecube.cpp:49
sampleWriter::Vertex_C
@ Vertex_C
Definition: testcreatecube.cpp:21
Dtk_SmartPtr::IsNULL
Dtk_bool IsNULL() const
Definition: util_ptr_dtk.hpp:118
Dtk_Fdt::Create
static Dtk_FdtPtr Create()
Base constructor.
Dtk_Info::SetId
Dtk_ErrorStatus SetId(const Dtk_Int32 &inId)
sampleWriter::MakeCyl
Dtk_SurfacePtr MakeCyl(const Dtk_pnt &O, double radius, double height)
Definition: testcreatecube.cpp:1736
sampleWriter::CreateMeshCubeFaces
void CreateMeshCubeFaces(Dtk_mesh *outCubeMesh)
Create Mesh Faces For Cube.
Definition: testcreatemesh.cpp:187
Dtk_transfo::setScale
void setScale(Dtk_Double64 scale)
Set a new scale.
Dtk_SmartPtr
Definition: util_ptr_dtk.hpp:37
Dtk_Polyline::Create
static Dtk_PolylinePtr Create(const Dtk_Polyline &inPolylineToCopy)
constructors returning Smart pointers
Dtk_Edge::Create
static Dtk_EdgePtr Create(const Dtk_BodyPtr &inParentBody)
Create an edge in a body.
sampleWriter::FaceFBDG
@ FaceFBDG
Definition: testcreatecube.cpp:71
sampleWriter::Lump
@ Lump
Definition: testcreatecube.cpp:16
sampleWriter::Coedge1_EA
@ Coedge1_EA
Definition: testcreatecube.cpp:47
Dtk_transfo::setYdir
void setYdir(const Dtk_dir &Y)
Set a new Y vector.
sampleWriter::MakeSegment2D
Dtk_CurvePtr MakeSegment2D(double xmin, double ymin, double xmax, double ymax)
Definition: testcreatecube.cpp:1713
Dtk_pnt
This is a mathematical point class.
Definition: dtk_pnt.hpp:22
sampleWriter::Coedge4_EH
@ Coedge4_EH
Definition: testcreatecube.cpp:61
sampleWriter::CreateTopoShell_2
void CreateTopoShell_2(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecylfdt.cpp:997
sampleWriter::CreateMeshCubeGeometry
void CreateMeshCubeGeometry(Dtk_tab< Dtk_pnt > &vertices, Dtk_tab< Dtk_dir > &normals, Dtk_tab< Dtk_Float32 > &uCoords, Dtk_tab< Dtk_Float32 > &vCoords)
Create Mesh Geometry For Cube.
Definition: testcreatemesh.cpp:17
Dtk_CompositeText
This is the composite text class. It's basically a Dtk_Text Container. This class represents a group ...
Definition: util_draw_dtk.hpp:1557
sampleWriter::CreateTopoEdge
void CreateTopoEdge(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecube.cpp:156
sampleWriter::Coedge2_BD
@ Coedge2_BD
Definition: testcreatecube.cpp:46
Dtk_Leader::Create
static Dtk_LeaderPtr Create()
Base constructor.
sampleWriter::FillInfos
void FillInfos(Dtk_InfoPtr &inf, Dtk_ID id, const Dtk_RGB &color)
Definition: testcreatecube.cpp:1783
Dtk_Camera::Create
static Dtk_CameraPtr Create()
Base constructor.
sampleWriter::CreateModelDisplayActivated
Dtk_ModelDisplayPtr CreateModelDisplayActivated()
Definition: testcreatefdt.cpp:228
Dtk_Leader::TerminatorTypeClosedArrow
@ TerminatorTypeClosedArrow
Definition: util_draw_dtk.hpp:2005
Dtk_TextStyle::CharHeight
Dtk_Double64 & CharHeight()
Retrieves the char height - get/set -.
Dtk_tab
This is a high level array class.
Definition: util_stl_dtk.hpp:85
Dtk_Vertex::Create
static Dtk_VertexPtr Create(const Dtk_BodyPtr &inParentBody)
Create a vertex in a body.
Dtk_Coedge::Create
static Dtk_CoedgePtr Create(const Dtk_BodyPtr &inParentBody)
Create a coedge in a body.
sampleWriter::MakeVertex
Dtk_VertexPtr MakeVertex(Dtk_BodyPtr &body, const Dtk_pnt &P)
Definition: testcreatecube.cpp:1696
Dtk_tab::size
Dtk_Size_t size() const
Returns the size of the array.
Definition: util_stl_dtk.hpp:502
sampleWriter::FaceEHCA
@ FaceEHCA
Definition: testcreatecube.cpp:74
sampleWriter::Vertex_F
@ Vertex_F
Definition: testcreatecube.cpp:24
sampleWriter::Coedge5_HC
@ Coedge5_HC
Definition: testcreatecube.cpp:58
sampleWriter::Coedge1_AB
@ Coedge1_AB
Definition: testcreatecube.cpp:40
sampleWriter::CreateTopoLump_2
void CreateTopoLump_2(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecylfdt.cpp:1076
sampleWriter::Coedge0_AB
@ Coedge0_AB
Definition: testcreatecube.cpp:39
sampleWriter::MakeEdge
Dtk_EdgePtr MakeEdge(Dtk_BodyPtr &body, const Dtk_VertexPtr &vstart, const Dtk_VertexPtr &vend, const Dtk_CurvePtr &curve3d, Dtk_ID id)
Definition: testcreatecube.cpp:1725
Dtk_Leader::LeaderTerminatorTypeEnum
LeaderTerminatorTypeEnum
Internal leader terminator type.
Definition: util_draw_dtk.hpp:1999
sampleWriter::MakePlane
Dtk_SurfacePtr MakePlane(const Dtk_pnt &O, const Dtk_pnt &N, double trim)
Definition: testcreatecube.cpp:1748
Dtk_tab::at
T & at(Dtk_Size_t k)
Definition: util_stl_dtk.hpp:396
Dtk_tab::push_back
void push_back(const T &x)
Inserts an element at the end of the array.
Definition: util_stl_dtk.hpp:415
Dtk_Shell::Create
static Dtk_ShellPtr Create(const Dtk_BodyPtr &inParentBody)
Create a shell in a body.
DTK_FRAME_TYPE_RECTANGLE
@ DTK_FRAME_TYPE_RECTANGLE
Definition: util_draw_dtk.hpp:136
sampleWriter::Coedge0_CA
@ Coedge0_CA
Definition: testcreatecube.cpp:41
Dtk_tab::clear
void clear(int no_delete=0)
Resets the Dtk_tab content.
Definition: util_stl_dtk.hpp:351
sampleWriter::CreateMeshCubeidGeometry
void CreateMeshCubeidGeometry(Dtk_tab< Dtk_pnt > &vertices, Dtk_tab< Dtk_dir > &normals, Dtk_tab< Dtk_Float32 > &uCoords, Dtk_tab< Dtk_Float32 > &vCoords, Dtk_pair< Dtk_pnt, Dtk_pnt > inPoints)
Create Mesh Geometry For Cuboid.
Definition: testcreatemesh.cpp:90
Dtk_Point::Create
static Dtk_PointPtr Create(const Dtk_Point &inToCopy)
constructors returning Smart pointers
Dtk_CompositeText::AddText
void AddText(Dtk_Text inText)
Adds a Dtk_Text to the Dtk_CompositeText.
sampleWriter::Edge_DC
@ Edge_DC
Definition: testcreatecube.cpp:29
Dtk_TextureInfos::CubicalMapping
@ CubicalMapping
Definition: dtk_render.hpp:33
Dtk_pnt::GetXYZ
void GetXYZ(Dtk_Double64 &outX, Dtk_Double64 &outY, Dtk_Double64 &outZ) const
Retrieves to the 3 coordinates of the class.
Definition: dtk_pnt.hpp:79
Dtk_RGB
Definition: dtk_rgb.hpp:7
Dtk_Info::SetColor
Dtk_ErrorStatus SetColor(const int &R, const int &G, const int &B)
Dtk_Info::create
static Dtk_SmartPtr< Dtk_Info > create()
Dtk_Oriented2dBBox
This is the base bounding box class. It's used into a lot of 2D Entities This class represents the ba...
Definition: util_draw_dtk.hpp:479
sampleWriter::Coedge1_FE
@ Coedge1_FE
Definition: testcreatecube.cpp:51
Dtk_mesh::add_mesh_face
int add_mesh_face(Dtk_mesh_face *inMesh_face)
Add a face (Dtk_mesh_face) to the mesh.
Dtk_dir
This is a mathematical direction class.
Definition: dtk_dir.hpp:15
Dtk_NurbsSurface::Create
static Dtk_NurbsSurfacePtr Create(const Dtk_NurbsSurface &s)
sampleWriter::MakeArc2D
Dtk_CurvePtr MakeArc2D(const Dtk_pnt &P0, double radius, double from, double to)
Definition: testcreatecube.cpp:1718
Dtk_mesh_face::add_polyline
int add_polyline(const Dtk_tab< Dtk_UInt32 > *inIndices)
Add one polyline.
Dtk_mesh_face::add_points
int add_points(const Dtk_tab< Dtk_UInt32 > *pnts)
sampleWriter::Vertex_E
@ Vertex_E
Definition: testcreatecube.cpp:23
sampleWriter::CreateTopoVertex_2
void CreateTopoVertex_2(std::map< Dtk_ID, Dtk_EntityPtr > &outArrayTopo, const Dtk_BodyPtr &inDtkBody)
Definition: testcreatecylfdt.cpp:47
Dtk_Volume::Create
static Dtk_VolumePtr Create(const Dtk_BodyPtr &inParentBody)
Create a volume in a body.
Dtk_NurbsCurve::Create
static Dtk_NurbsCurvePtr Create(const Dtk_NurbsCurve &s)
constructors returning Smart pointers
Dtk_MetaData::CreateMetaData
static Dtk_MetaDataPtr CreateMetaData(const MetaDataTypeEnum &inEnumType, Dtk_string inTitle, Dtk_string inValue, Dtk_string inValueType=Dtk_string(L"STRING"))
Create a Dtk_MetaDataPtr .
DTK_PI
#define DTK_PI
Definition: str_def.h:8
sampleWriter::Loop3_GDCH
@ Loop3_GDCH
Definition: testcreatecube.cpp:66
Dtk_Entity::info
Dtk_InfoPtr & info()
sampleWriter::Loop4_EFGH
@ Loop4_EFGH
Definition: testcreatecube.cpp:67
sampleWriter::Loop2_FBDG
@ Loop2_FBDG
Definition: testcreatecube.cpp:65
sampleWriter::Edge_HG
@ Edge_HG
Definition: testcreatecube.cpp:37
Dtk_CylindricalSurface::Create
static Dtk_CylindricalSurfacePtr Create(const Dtk_pnt &inOrigin, const Dtk_dir &inNormal, const Dtk_dir &inUDirection, const Dtk_Double64 &inRadius, const Dtk_dir &inYDirection=Dtk_dir())
Create an infinite cylinder.