sampleWriter Namespace Reference

Namespaces
	layer

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 ()
	Creates a reference body (infinite + reference flags) containing a single named axis line with metadata. More...
Dtk_AxisSystemPtr	CreateAxisSystem ()
	Creates a named axis system with a custom orientation matrix, red color, layer 123, and metadata. More...
Dtk_BodyPtr	CreateConstructionPlane ()
	Creates a construction plane body: an infinite plane at Y=50, returned as an open shell. More...
Dtk_BodyPtr	CreateCube ()
	Creates a 100x100x100 mm closed BRep cube body. Builds the full BRep hierarchy (Vertex, Edge, Coedge, Loop, Face, Shell, Volume, Lump), assigns named topology entities, per-face colors, IDs, and metadata. More...
Dtk_BodyPtr	CreateCube_2 ()
	Creates a 100x100x100 mm BRep cube body augmented with face IDs (required for FDT linking), solid validation properties (area, volume, centre of gravity) and a face-level user attribute. More...
Dtk_RenderInfosPtr	CreateCubeRenderInfos ()
	Creates a Dtk_RenderInfos object with ambient, diffuse, and specular lighting and a texture for use on a cube mesh. More...
Dtk_BodyPtr	CreateCurves ()
	Creates a wireframe body containing a circle, ellipse, line, and NURBS curve, each with a distinct color and name. More...
Dtk_BodyPtr	CreateCurves_2 ()
	Creates a wireframe body with colored curves, augmented with additional curve-level attributes. More...
Dtk_BodyPtr	CreateCurvesStyle ()
	Creates a wireframe body demonstrating curve display styles: thick circle (4 mm), dashed blue circle, and dotted magenta circle (2 mm). More...
Dtk_BodyPtr	CreateCyl (double radius, double height)
	Creates a BRep cylinder body with the given radius and height using analytical cylindrical and planar surfaces. More...
Dtk_BodyPtr	CreateCylinder ()
	Creates a closed BRep cylinder body (radius 50, height 100) with two circular faces, a lateral cylindrical face, named face IDs, validation properties, and mesh tessellation. More...
Dtk_FdtPtr	CreateDimension ()
	Creates a linear dimension FDT with a leader, dual-value text, and a frame. More...
Dtk_BodyPtr	CreateEsquisse2D ()
	Creates a 2D wireframe sketch body (planar, lying in the XY plane) containing lines, arc circles, circles, ellipses, and arc ellipses. More...
Dtk_BodyPtr	CreateEsquisse3D ()
	Creates a 3D wireframe sketch body containing points, lines, NURBS splines, circles, arc circles, ellipses, and arc ellipses. More...
Dtk_FdtPtr	CreateFdtDatum ()
	Creates simple Datum. More...
Dtk_FdtPtr	CreateGeometricalTolerance ()
	Creates a geometric tolerance FDT: cylindricity position tolerance | 0.02(M) | A |. More...
Dtk_BodyPtr	CreateInfinitePlane ()
	Creates a reference body flagged as an infinite plane (InfiniteGeometryFlag + RefEntityFlag), with color and metadata. More...
Dtk_MeshPtr	CreateMeshCube ()
	Mesh Cube sample. More...
Dtk_MeshPtr	CreateMeshCubeVertexColor ()
	Creates a unit cube mesh with per-vertex color data (red, green, blue, white cycling per face). More...
Dtk_MeshPtr	CreateMeshCuboid (const Dtk_pnt &inFirstPoint, const Dtk_pnt &inSecondPoint)
	Creates an axis-aligned cuboid mesh from two opposite corner points. More...
Dtk_MeshPtr	CreateMeshCylinder (int nbpoints)
	Mesh Cylinder sample. More...
Dtk_MeshPtr	CreateMeshPoints ()
	Points mesh sample. More...
Dtk_MeshPtr	CreateMeshWire ()
	Wire mesh sample. More...
Dtk_BodyPtr	CreateMixedBody ()
	Creates a mixed body combining a closed BRep cube (solid) with additional free surfaces and wireframe curves in the same body. More...
Dtk_ModelDisplayPtr	CreateModelDisplayActivated ()
	Creates an activated (visible) model display "MyView1" with a perspective camera. More...
Dtk_ModelDisplayPtr	CreateModelDisplayDesactivated ()
	Creates a deactivated (hidden) model display "MyView2" with an orthographic camera. More...
Dtk_ModelDisplayPtr	CreateModelDisplayWithSection ()
	Creates a deactivated model display "MySectionView" with a section cut plane applied. More...
Dtk_BodyPtr	CreateOpenShell ()
	Creates an open shell body containing a single trimmed cylindrical surface (half cylinder, not closed). More...
Dtk_BodyPtr	CreateOpenShell_2 ()
	Creates an open shell body (trimmed cylindrical surface) augmented with open-shell attributes. More...
Dtk_BodyPtr	CreatePoint ()
	Creates a wireframe body containing a single named red point with metadata. More...
Dtk_MeshPtr	CreateTexturedMeshCube (const Dtk_string &inImageDirectory)
	Textured Mesh Cube sample. More...
void	FillFacesColors (Dtk_MeshPtr &inoutCubeMesh)
	Filling mesh faces with colors. More...

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

     {
          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,
     };

Function Documentation

CreateAxis()

Dtk_BodyPtr sampleWriter::CreateAxis

(

)

Creates a reference body (infinite + reference flags) containing a single named axis line with metadata.

Creates a reference axis containing a named axis, flagged as infinite geometry.

     {
          Dtk_BodyPtr mybody = Dtk_Body::Create();
          Dtk_ShellPtr shell = Dtk_Shell::Create( mybody );
          Dtk_tab<Dtk_CurvePtr> CurveArray;
 
          mybody->info() = Dtk_Info::Create();
          mybody->get_info()->SetInfiniteGeometryFlag( DTK_TRUE );
          mybody->get_info()->SetRefEntityFlag( DTK_TRUE );
 
 
          Dtk_LinePtr lineptr = Dtk_Line::Create( Dtk_pnt( -41, -42, -50 ), Dtk_pnt( -51, -52, -50 ) );
          lineptr->info() = Dtk_Info::Create();
          lineptr->info()->SetColor( Dtk_RGB( 0, 255, 25, 255 ) );
          lineptr->info()->SetName( L"myaxe" );
 
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of myaxe", L"Value of myaxe" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          lineptr->info()->SetMetaData( ArrayMetadataEntity );
 
          CurveArray.push_back( Dtk_CurvePtr::DtkDynamicCast( lineptr ) );
 
          shell->AddWire( CurveArray );
          mybody->AddWireShell( shell );
 
          return mybody;
     }

CreateAxisSystem()

Dtk_AxisSystemPtr sampleWriter::CreateAxisSystem

(

)

Creates a named axis system with a custom orientation matrix, red color, layer 123, and metadata.

Creates a named axis system with a custom orientation, color, layer, and metadata.

     {
          Dtk_AxisSystemPtr mycsystem = Dtk_AxisSystem::Create();
          Dtk_transfo dtk_transfo;
          dtk_transfo.setXdir( 0.0, 0.0, 1.0 );
          dtk_transfo.setYdir( -1.0, 0.0, 0.0 );
          dtk_transfo.setZdir( 0.0, -1.0, 0.0 );
          dtk_transfo.setOrigin( Dtk_pnt( -41, -42, -50 ) );
          mycsystem->SetMatrix( dtk_transfo );
          mycsystem->info() = Dtk_Info::Create();
          mycsystem->info()->SetName( L"mycsystem" );
          mycsystem->info()->SetColor( Dtk_RGB( 255, 0, 0, 255 ) );
          mycsystem->info()->SetLayer( 123 );
 
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mycsystem", L"Value of mycsystem" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          mycsystem->info()->SetMetaData( ArrayMetadataEntity );
 
          //Uncomment to put the AxisSystem as Blanked
          //mycsystem->info()->SetBlankedStatus(DTK_TRUE);
 
          return mycsystem;
     }

CreateConstructionPlane()

Dtk_BodyPtr sampleWriter::CreateConstructionPlane

(

)

Creates a construction plane body: an infinite plane at Y=50, returned as an open shell.

Creates a body containing a construction (reference) plane at the origin.

     {
          Dtk_BodyPtr body = Dtk_Body::Create();
          Dtk_PlaneSurfacePtr plan = Dtk_PlaneSurface::Create( Dtk_pnt( 0., 50., 0. ), Dtk_dir( 0., 1., 0. ), Dtk_dir( 1., 0., 0. ) );
          Dtk_FacePtr face = Dtk_Face::Create( body );
          face->SetGeom( Dtk_SurfacePtr::DtkDynamicCast( plan ) );
          Dtk_ShellPtr shell = Dtk_Shell::Create( body );
          shell->AddFace( face, DTK_TRUE );
          body->AddOpenShell( shell );
          body->info() = Dtk_Info::Create();
          body->info()->SetName( "Plane Y=50" );
          return body;
     }

CreateCube()

Dtk_BodyPtr sampleWriter::CreateCube

(

)

Creates a 100x100x100 mm closed BRep cube body. Builds the full BRep hierarchy (Vertex, Edge, Coedge, Loop, Face, Shell, Volume, Lump), assigns named topology entities, per-face colors, IDs, and metadata.

Creates a 100x100x100 mm closed BRep cube body with 6 faces, named topology entities, and metadata.

     {
          std::map<Dtk_ID, Dtk_EntityPtr> array_topo;
 
          Dtk_BodyPtr body = Dtk_Body::Create();                  // create the Body
          body->info() = Dtk_Info::Create();
          body->info()->SetName( L"Body" );
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of Body", L"Value of Body" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          body->info()->SetMetaData( ArrayMetadataEntity );
 
          CreateTopoVertex( array_topo, body ); //create all Vertex
          CreateTopoEdge( array_topo, body ); //create all Edge
          CreateTopoCoEdge( array_topo, body );//create all Coedge
          CreateTopoLoop( array_topo, body );//create all Loop
          CreateTopoFace( array_topo, body );//create all Face
          CreateTopoShell( array_topo, body );//create all Shell
          CreateTopoVolume( array_topo, body );//create all Volume
          CreateTopoLump( array_topo, body );//create all Lump
 
          body->AddLump( Dtk_LumpPtr::DtkDynamicCast( array_topo[ Lump ] ) );                // add the Lump into the body.
 
          return body;
     }

CreateCube_2()

Dtk_BodyPtr sampleWriter::CreateCube_2

(

)

Creates a 100x100x100 mm BRep cube body augmented with face IDs (required for FDT linking), solid validation properties (area, volume, centre of gravity) and a face-level user attribute.

Creates a 100x100x100 mm BRep cube body augmented with face IDs required for FDT attachment, validation properties, and face-level user attributes.

     {
          std::map<Dtk_ID, Dtk_EntityPtr> array_topo;
 
          Dtk_BodyPtr body = Dtk_Body::Create();                  // create the Body
 
          CreateTopoVertex_2( array_topo, body ); //create all Vertex
          CreateTopoEdge_2( array_topo, body ); //create all Edge
          CreateTopoCoEdge_2( array_topo, body );//create all Coedge
          CreateTopoLoop_2( array_topo, body );//create all Loop
          CreateTopoFace_2( array_topo, body );//create all Face
          CreateTopoShell_2( array_topo, body );//create all Shell
          CreateTopoVolume_2( array_topo, body );//create all Volume
          CreateTopoLump_2( array_topo, body );//create all Lump
 
          body->AddLump( Dtk_LumpPtr::DtkDynamicCast( array_topo[ 1 ] ) );                // add the Lump into the body.
 
          // V78 : val prop sur Body : IGNORED
          Dtk_InfoPtr& body_info = body->info();
          if( body_info.IsNULL() ) body_info = Dtk_Info::Create();
          Dtk_Val valprop_area( "1234 mm2" );
          body_info->AddAttribute( "geometric validation property :  : surface area measure", valprop_area );
          Dtk_Val valprop_volume( "5678 mm3" );
          body_info->AddAttribute( "geometric validation property :  : volume measure", valprop_volume );
          Dtk_Val valprop_CG( Dtk_pnt( 12., 34., 56. ) );
          body_info->AddAttribute( "geometric validation property :  : centre point", valprop_CG );
 
          return body;
     }

CreateCubeRenderInfos()

Dtk_RenderInfosPtr sampleWriter::CreateCubeRenderInfos

(

)

Creates a Dtk_RenderInfos object with ambient, diffuse, and specular lighting and a texture for use on a cube mesh.

Creates a Dtk_RenderInfos object with material and color information for a cube.

     {
          //Variables
          Dtk_RGB                      ambiant;
          Dtk_RGB                      diffuse;
          Dtk_RGB                      specular;
          Dtk_LightMapPtr              lightMap;
          Dtk_TextureInfosPtr          texture;
          Dtk_string                   fileName;
 
          //Creating lighting
          ambiant.SetRGBA( 255, 255, 255 );
          diffuse.SetRGBA( 255, 255, 255 );
          specular.SetRGBA( 255, 255, 255 );
          lightMap = Dtk_LightMap::Create( ambiant, diffuse, specular );
 
          lightMap->SetTransparentRatio( 0.0 );
 
          Dtk_RGB reflective;
          reflective.SetRGBA( 255, 255, 255 );
          lightMap->AddReflectiveColor( reflective );
 
          lightMap->SetShininessRatio( 0.003375 );
 
          //Creating texture using cubical mapping
          texture = Dtk_TextureInfos::Create( Dtk_TextureInfos::CubicalMapping );
          //Setting image to the texture
          fileName = "..\\InputFiles\\Images\\sample.bmp";
          texture->SetImagePath( fileName );
          //Scaling the texture
          texture->SetScale( 2, 2 );
 
          //Finally creating render informations
          Dtk_RenderInfosPtr renderInfo = Dtk_RenderInfos::Create( "Rendering", lightMap, texture );
 
          return renderInfo;
     }

CreateCurves()

Dtk_BodyPtr sampleWriter::CreateCurves

(

)

Creates a wireframe body containing a circle, ellipse, line, and NURBS curve, each with a distinct color and name.

Creates a wireframe body containing a circle, ellipse, line, and NURBS curve, each with a distinct color.

     {
          Dtk_tab<Dtk_CurvePtr> mycurves;
          Dtk_BodyPtr mybody;
          mybody = Dtk_Body::Create();
          Dtk_ShellPtr myshell;
          myshell = Dtk_Shell::Create( mybody );
 
          Dtk_EllipsePtr myellipse;
 
          //add circle curve
          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 );
          Dtk_CurvePtr mycurve;
          mycurve = Dtk_CurvePtr::DtkDynamicCast( myellipse );
          mycurve->info() = Dtk_Info::Create();
          mycurve->info()->SetColor( Dtk_RGB( 255, 0, 255 ) );
          mycurve->info()->SetName( "mycircle" );
          mycurves.push_back( mycurve );
 
 
          //add ellipse curve
          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 );
          mycurve = Dtk_CurvePtr::DtkDynamicCast( myellipse );
          mycurve->info() = Dtk_Info::Create();
          mycurve->info()->SetColor( Dtk_RGB( 255, 255, 0 ) );
          mycurve->info()->SetName( "myellipse" );
          mycurves.push_back( mycurve );
 
 
          //add line curve
          Dtk_LinePtr myline;
          myline = Dtk_Line::Create( Dtk_pnt( -5.0, 0.0, 0.0 ), Dtk_pnt( 5.0, 0.0, 0.0 ) );
          mycurve = Dtk_CurvePtr::DtkDynamicCast( myline );
          mycurve->info() = Dtk_Info::Create();
          mycurve->info()->SetColor( Dtk_RGB( 0, 0, 255 ) );
          mycurve->info()->SetName( "myline" );
          mycurves.push_back( mycurve );
 
 
          //add nurbs curve
          //nurbs with 4 Control Points 
          //respect num_points = Knots.size() - Degree - 1;
          Dtk_tab<Dtk_pnt> ControlPoints;
          Dtk_tab<Dtk_Double64> Knots;
          Dtk_Int32 Degree = 3;
          ControlPoints.resize( 4 );
          ControlPoints[ 0 ] = Dtk_pnt( -5.0, 0.0, 0.0 );
          ControlPoints[ 1 ] = Dtk_pnt( -2.0, 5.0, 0. );
          ControlPoints[ 2 ] = Dtk_pnt( 2.0, -5.0, 0. );
          ControlPoints[ 3 ] = Dtk_pnt( 5.0, 0.0, 0. );
          Knots.resize( 8 );
          Knots[ 0 ] = Knots[ 1 ] = Knots[ 2 ] = Knots[ 3 ] = 0.0;
          Knots[ 4 ] = Knots[ 5 ] = Knots[ 6 ] = Knots[ 7 ] = 1.0;
 
          Dtk_NurbsCurvePtr cnurbs = Dtk_NurbsCurve::Create( Degree, Knots, ControlPoints );
          mycurve = Dtk_CurvePtr::DtkDynamicCast( cnurbs );
          mycurve->info() = Dtk_Info::Create();
          mycurve->info()->SetColor( Dtk_RGB( 0, 255, 0 ) );
          mycurve->info()->SetName( "mynurbs" );
          mycurves.push_back( mycurve );
 
 
 
          myshell->AddWire( mycurves );
          mybody->AddWireShell( myshell );
 
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mycurve", L"Value of mycurve" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
 
          mybody->info() = Dtk_Info::Create();
          mybody->info()->SetMetaData( ArrayMetadataEntity );
 
          return mybody;
     }

CreateCurves_2()

Dtk_BodyPtr sampleWriter::CreateCurves_2

(

)

Creates a wireframe body with colored curves, augmented with additional curve-level attributes.

Creates a wireframe body with colored curves, augmented with additional attributes.

     {
          Dtk_tab<Dtk_CurvePtr> mycurves;
          Dtk_BodyPtr mysbody;
          mysbody = Dtk_Body::Create();
 
          Dtk_ShellPtr myshell;
          myshell = Dtk_Shell::Create( mysbody );
 
          Dtk_EllipsePtr myellipse;
          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 );
 
          Dtk_CurvePtr mycurve;
          mycurve = Dtk_CurvePtr::DtkDynamicCast( myellipse );
 
          mycurve->info() = Dtk_Info::Create();
          mycurve->info()->SetColor( Dtk_RGB( 255, 0, 255 ) );
          mycurve->info()->SetName( "mycircle" );
 
          mycurves.push_back( mycurve );
 
          Dtk_LinePtr myline;
          myline = Dtk_Line::Create( Dtk_pnt( -5.0, 0.0, 0.0 ), Dtk_pnt( 5.0, 0.0, 0.0 ) );
          mycurve = Dtk_CurvePtr::DtkDynamicCast( myline );
 
          mycurve->info() = Dtk_Info::Create();
          mycurve->info()->SetColor( Dtk_RGB( 0, 0, 255 ) );
          mycurve->info()->SetName( "myline" );
 
          mycurves.push_back( mycurve );
 
          myshell->AddWire( mycurves );
          mysbody->AddWireShell( myshell );
 
          //  Val Prop on Body : not yet supported
          Dtk_InfoPtr& body_info = mysbody->info();
          if( body_info.IsNULL() ) body_info = Dtk_Info::Create();
          Dtk_Val valprop_curve_length( "1234 mm" );
          body_info->AddAttribute( "geometric validation property :  : curve length measure", valprop_curve_length );
 
          return mysbody;
     }

CreateCurvesStyle()

Dtk_BodyPtr sampleWriter::CreateCurvesStyle

(

)

Creates a wireframe body demonstrating curve display styles: thick circle (4 mm), dashed blue circle, and dotted magenta circle (2 mm).

Creates a wireframe body demonstrating curve display styles: custom thickness and dashed/dotted line types.

     {
          Dtk_tab<Dtk_CurvePtr> mycurves;
          Dtk_BodyPtr mybody;
          mybody = Dtk_Body::Create();
          Dtk_ShellPtr myshell;
          myshell = Dtk_Shell::Create( mybody );
 
          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 );
          ellipsethick->info() = Dtk_Info::Create();
          ellipsethick->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
          ellipsethick->info()->SetCurveThickNessInMM( 4 );
          mycurves.push_back( Dtk_CurvePtr::DtkDynamicCast( ellipsethick ) );
 
 
          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 );
          ellipsedash->info() = Dtk_Info::Create();
          ellipsedash->info()->SetColor( Dtk_RGB( 0, 0, 255 ) );
          ellipsedash->info()->SetCurveLineType( DTK_DASHED );
          mycurves.push_back( Dtk_CurvePtr::DtkDynamicCast( ellipsedash ) );
 
          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 );
          ellipsedotted->info() = Dtk_Info::Create();
          ellipsedotted->info()->SetColor( Dtk_RGB( 255, 0, 255 ) );
          ellipsedotted->info()->SetCurveLineType( DTK_DOTTED );
          ellipsedotted->info()->SetCurveThickNessInMM( 2 );
          mycurves.push_back( Dtk_CurvePtr::DtkDynamicCast( ellipsedotted ) );
 
          myshell->AddWire( mycurves );
          mybody->AddWireShell( myshell );
          mybody->info() = Dtk_Info::Create();
 
          return mybody;
     }

CreateCyl()

Dtk_BodyPtr sampleWriter::CreateCyl	(	double	radius,
		double	height
	)

Creates a BRep cylinder body with the given radius and height using analytical cylindrical and planar surfaces.

Creates a BRep cylinder body with the given radius and height.

     {
          Dtk_BodyPtr body = Dtk_Body::Create();
          Dtk_LumpPtr lump = Dtk_Lump::Create( body );
          Dtk_VolumePtr volume = Dtk_Volume::Create( body );
          Dtk_ShellPtr shell = Dtk_Shell::Create( body );
          body->AddLump( lump );
          lump->AddVolume( volume );
          volume->AddOuterShell( shell );
 
          Dtk_pnt P[ 4 ];
          P[ 0 ] = Dtk_pnt( radius, 0, 0 );
          P[ 1 ] = Dtk_pnt( radius, 0, height );
          P[ 2 ] = Dtk_pnt( -radius, 0, height );
          P[ 3 ] = Dtk_pnt( -radius, 0, 0 );
          Dtk_VertexPtr v[ 4 ];
          Dtk_Size_t i;
          for( i = 0; i < 4; i++ )
               v[ i ] = MakeVertex( body, P[ i ] );
          Dtk_EdgePtr e[ 6 ];
          e[ 0 ] = MakeEdge( body, v[ 0 ], v[ 1 ], MakeSegment( P[ 0 ], P[ 1 ] ), 1 );
          e[ 1 ] = MakeEdge( body, v[ 2 ], v[ 3 ], MakeSegment( P[ 2 ], P[ 3 ] ), 2 );
          e[ 2 ] = MakeEdge( body, v[ 3 ], v[ 0 ], MakeArc2D( Dtk_pnt(), radius, -DTK_PI, 0 ), 3 );
          e[ 3 ] = MakeEdge( body, v[ 0 ], v[ 3 ], MakeArc2D( Dtk_pnt(), radius, 0, DTK_PI ), 4 );
          e[ 4 ] = MakeEdge( body, v[ 2 ], v[ 1 ], MakeArc2D( Dtk_pnt( 0, 0, height ), radius, -DTK_PI, 0 ), 5 );
          e[ 5 ] = MakeEdge( body, v[ 1 ], v[ 2 ], MakeArc2D( Dtk_pnt( 0, 0, height ), radius, 0, DTK_PI ), 6 );
 
          Dtk_FacePtr half1 = MakeOuterFace( body, MakeCyl( Dtk_pnt(), radius, height ),
                                                     MakeCoedge( body, e[ 0 ], DTK_TRUE, MakeSegment2D( 0, 0, 0, height ) ),
                                                     MakeCoedge( body, e[ 4 ], DTK_FALSE, MakeSegment2D( 0, height, -DTK_PI, height ) ),
                                                     MakeCoedge( body, e[ 1 ], DTK_TRUE, MakeSegment2D( -DTK_PI, height, -DTK_PI, 0 ) ),
                                                     MakeCoedge( body, e[ 2 ], DTK_TRUE, MakeSegment2D( -DTK_PI, 0, 0, 0 ) )
          );
          shell->AddFace( half1, DTK_TRUE );
          FillInfos( half1->info(), 1, Dtk_RGB() );
 
          Dtk_FacePtr half2 = MakeOuterFace( body, MakeCyl( Dtk_pnt(), radius, height ),
                                                     MakeCoedge( body, e[ 3 ], DTK_TRUE, MakeSegment2D( 0, 0, DTK_PI, 0 ) ),
                                                     MakeCoedge( body, e[ 1 ], DTK_FALSE, MakeSegment2D( DTK_PI, 0, DTK_PI, height ) ),
                                                     MakeCoedge( body, e[ 5 ], DTK_FALSE, MakeSegment2D( DTK_PI, height, 0, height ) ),
                                                     MakeCoedge( body, e[ 0 ], DTK_FALSE, MakeSegment2D( 0, height, 0, 0 ) )
          );
          shell->AddFace( half2, DTK_TRUE );
          FillInfos( half2->info(), 2, Dtk_RGB() );
 
          Dtk_FacePtr plandown = MakeOuterFace( body, MakePlane( Dtk_pnt(), Dtk_dir( 0, 0, -1 ), radius ),
                                                         MakeCoedge( body, e[ 2 ], DTK_FALSE, MakeArc2D( Dtk_pnt(), radius, 0, DTK_PI ) ),
                                                         MakeCoedge( body, e[ 3 ], DTK_FALSE, MakeArc2D( Dtk_pnt(), radius, DTK_PI, 2 * DTK_PI ) ),
                                                         NULL, NULL
          );
          shell->AddFace( plandown, DTK_TRUE );
          FillInfos( plandown->info(), 3, Dtk_RGB() );
 
          Dtk_FacePtr planup = MakeOuterFace( body, MakePlane( Dtk_pnt( 0, 0, height ), Dtk_dir( 0, 0, 1 ), radius ),
                                                       MakeCoedge( body, e[ 4 ], DTK_TRUE, MakeArc2D( Dtk_pnt(), radius, -DTK_PI, 0 ) ),
                                                       MakeCoedge( body, e[ 5 ], DTK_TRUE, MakeArc2D( Dtk_pnt(), radius, 0, DTK_PI ) ),
                                                       NULL, NULL
          );
          shell->AddFace( planup, DTK_TRUE );
          FillInfos( planup->info(), 4, Dtk_RGB( 0, 255, 0 ) );
          body->info() = Dtk_Info::Create();
 
          return body;
     }

CreateCylinder()

Dtk_BodyPtr sampleWriter::CreateCylinder

(

)

Creates a closed BRep cylinder body (radius 50, height 100) with two circular faces, a lateral cylindrical face, named face IDs, validation properties, and mesh tessellation.

Creates a closed BRep cylinder body with its triangulated tessellation, ready for writing.

     {
          Dtk_BodyPtr mysbody;
          mysbody = Dtk_Body::Create();
 
          //  Curves of edges
          Dtk_PointPtr P1 = Dtk_Point::Create( 50., 0., 100. );
          Dtk_PointPtr P2 = Dtk_Point::Create( 50., 0., 0. );
          Dtk_pnt cent1( 0., 0., 100. );
          Dtk_EllipsePtr circ1 = Dtk_Ellipse::Create( cent1, Dtk_dir( 0., 0., 1. ), Dtk_dir( 1., 0., 0. ), 50. );
          Dtk_pnt cent2( 0., 0., 0. );
          Dtk_EllipsePtr circ2 = Dtk_Ellipse::Create( cent2, Dtk_dir( 0., 0., 1. ), Dtk_dir( 1., 0., 0. ), 50. );
          Dtk_LinePtr seam = Dtk_Line::Create( Dtk_pnt( 50., 0., 0. ), Dtk_pnt( 50., 0., 100. ) );
          //  Surfaces of faces
          //  Notice : for tessellation, it is required to record the UV trim in surfaces
          double trim[ 4 ];
          Dtk_PlaneSurfacePtr plan1 = Dtk_PlaneSurface::Create( cent1, Dtk_dir( 0., 0., 1. ), Dtk_dir( 1., 0., 0. ) );
          trim[ 0 ] = -100.; trim[ 1 ] = 100.; trim[ 2 ] = -100.; trim[ 3 ] = 100.;
          plan1->SetTrimUVBox( trim );
          Dtk_PlaneSurfacePtr plan2 = Dtk_PlaneSurface::Create( cent2, Dtk_dir( 0., 0., 1. ), Dtk_dir( 1., 0., 0. ) );
          plan2->SetTrimUVBox( trim );
          Dtk_CylindricalSurfacePtr cylsurf = Dtk_CylindricalSurface::Create( cent2, Dtk_dir( 0., 0., 1. ), Dtk_dir( 1., 0., 0. ), 50 );
          trim[ 0 ] = 0.; trim[ 1 ] = 2. * DTK_PI;
          cylsurf->SetTrimUVBox( trim );
 
          //  Topology
          //  Vertices
          Dtk_VertexPtr V1 = Dtk_Vertex::Create( mysbody );
          V1->SetGeom( P1 );
          Dtk_VertexPtr V2 = Dtk_Vertex::Create( mysbody );
          V2->SetGeom( P2 );
          //  Edges
          Dtk_EdgePtr E0 = Dtk_Edge::Create( mysbody );
          E0->SetGeom( Dtk_CurvePtr::DtkDynamicCast( seam ) );
          E0->SetStartVertex( V1 );
          E0->SetEndVertex( V2 );
          Dtk_EdgePtr E1 = Dtk_Edge::Create( mysbody );
          E1->SetGeom( Dtk_CurvePtr::DtkDynamicCast( circ1 ) );
          E1->SetStartVertex( V1 );
          E1->SetEndVertex( V1 );
          Dtk_EdgePtr E2 = Dtk_Edge::Create( mysbody );
          E2->SetGeom( Dtk_CurvePtr::DtkDynamicCast( circ2 ) );
          E2->SetStartVertex( V2 );
          E2->SetEndVertex( V2 );
 
          //  Faces
          Dtk_FacePtr F0 = Dtk_Face::Create( mysbody );
          F0->SetGeom( Dtk_SurfacePtr::DtkDynamicCast( cylsurf ) );
          SetTopoFaceID( F0, 10 );
          Dtk_FacePtr F1 = Dtk_Face::Create( mysbody );
          F1->SetGeom( Dtk_SurfacePtr::DtkDynamicCast( plan1 ) );
          SetTopoFaceID( F1, 20 );
          //  test for face color different from body color
          F1->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );  // info created by SetTopoFaceID
          Dtk_FacePtr F2 = Dtk_Face::Create( mysbody );
          F2->SetGeom( Dtk_SurfacePtr::DtkDynamicCast( plan2 ) );
          SetTopoFaceID( F2, 30 );
          //  Loops + coedges
          Dtk_LoopPtr L0 = Dtk_Loop::Create( mysbody );
          Dtk_CoedgePtr C01 = Dtk_Coedge::Create( mysbody );
          C01->SetEdge( E1 );
          L0->AddCoedge( C01, DTK_FALSE );
          Dtk_CoedgePtr C02 = Dtk_Coedge::Create( mysbody );
          C02->SetEdge( E0 );
          L0->AddCoedge( C02, DTK_FALSE );
          Dtk_CoedgePtr C03 = Dtk_Coedge::Create( mysbody );
          C03->SetEdge( E2 );
          L0->AddCoedge( C03, DTK_TRUE );
          Dtk_CoedgePtr C04 = Dtk_Coedge::Create( mysbody );
          C04->SetEdge( E0 );
          L0->AddCoedge( C04, DTK_TRUE );
          F0->AddOuterLoop( L0 );
 
          Dtk_LoopPtr L1 = Dtk_Loop::Create( mysbody );
          Dtk_CoedgePtr C1 = Dtk_Coedge::Create( mysbody );
          C1->SetEdge( E1 );
          L1->AddCoedge( C1, DTK_TRUE );
          F1->AddOuterLoop( L1 );
 
          Dtk_LoopPtr L2 = Dtk_Loop::Create( mysbody );
          Dtk_CoedgePtr C2 = Dtk_Coedge::Create( mysbody );
          C2->SetEdge( E2 );
          L2->AddCoedge( C2, DTK_TRUE );
          F2->AddOuterLoop( L2 );
 
          //  Shell, Volume
          Dtk_ShellPtr SH = Dtk_Shell::Create( mysbody );
          SH->AddFace( F0, DTK_TRUE );
          SH->AddFace( F1, DTK_TRUE );
          SH->AddFace( F2, DTK_FALSE );
          Dtk_VolumePtr VOL = Dtk_Volume::Create( mysbody );
          VOL->AddOuterShell( SH );
          Dtk_LumpPtr Lump = Dtk_Lump::Create( mysbody );
          Lump->AddVolume( VOL );
          mysbody->AddLump( Lump );
          if( mysbody->info().IsNULL() ) mysbody->info() = Dtk_Info::Create();
          mysbody->info()->SetColor( Dtk_RGB( 0, 255, 0 ) );//Whole body color
 
          return mysbody;
     }

CreateDimension()

Dtk_FdtPtr sampleWriter::CreateDimension

(

)

Creates a linear dimension FDT with a leader, dual-value text, and a frame.

Creates a linear dimension FDT between two points.

     {
          Dtk_FdtPtr fdt = Dtk_Fdt::Create();
 
          Dtk_SymbolPtr symbol = Dtk_Symbol::Create();
 
 
          //  Creation of Text info
          Dtk_InfoPtr text_info = Dtk_Info::Create();
 
          //Setting text style
          Dtk_bool horiz_vert = 0, mirror = 0, font_index = 0;
          double slant = 0.;
          Dtk_TextStyle text_style;
          //Text height
          text_style.CharHeight() = 3.5;
          //Text width
          text_style.CharWidth() = 2.1;
          //Text slant
          text_style.Slant() = slant;
 
          //Creating text value "200"
          Dtk_string str( "200" );
          //Creating text 2D Bounding box
          Dtk_pnt location( -5., 20. );
          double x_len = 15., y_len = 5.;
          Dtk_dir x_dir( 1., 0., 0. ), y_dir( 0., 0., 1. );
          Dtk_Oriented2dBBox inbox( location, x_len, y_len, x_dir, y_dir );
 
          Dtk_anchor_type dtk_align = DTK_ANCHOR_MIDDLE_CENTER;
          DTK_Text_type text_type = dtk_text_type_value;
 
          //Creating the text itself giving :
          //      - its value
          //      - inside and outside boxes
          //      - anchor type
          //      - text type
          //      - horizontal/vertical text orientation
          //      - text infos 
          //      - text style
          //      - text slant - PI / 2.0 for normal text -
          //      - font index
          //      - mirroring type
          Dtk_Text dtk_text( str, inbox, inbox, dtk_align, text_type, horiz_vert, text_info, text_style, slant, font_index, mirror );
          Dtk_CompositeText texts;
          texts.AddText( dtk_text );
 
          //Creating the Dimension itself
          Dtk_Dimension::DimensionTypeEnum dimensionType = Dtk_Dimension::DistanceDimension;
          Dtk_DimensionPtr dimension = Dtk_Dimension::Create( dimensionType, texts );
          //Adding dimension to FDT
          fdt->Sub2DEntity() = Dtk_2dEntityPtr::DtkDynamicCast( dimension );
 
          //Creating the Leader lines
          //Setting leader terminator type
          Dtk_Leader::LeaderTerminatorTypeEnum termintator_type = Dtk_Leader::TerminatorTypeClosedArrow;
          //Setting leader terminator size
          double arrow_width = 5., arrow_length = 5.;
          //Creating first leader
          //Setting the Arrow location
          Dtk_pnt leader1_arrow_location = Dtk_pnt( 100., 23., 0. );
          //Setting the leader position
          Dtk_transfo leader1_pos;
          leader1_pos.setOrigin( Dtk_pnt( 0., 23., 0. ) );
          //Setting the leader points
          Dtk_tab<Dtk_pnt> leader1_pts;
          leader1_pts.push_back( Dtk_pnt( 10., 23., 0. ) );
          //Creating the first leader itself
          Dtk_LeaderPtr leader1 = Dtk_Leader::Create( arrow_width, arrow_length, leader1_arrow_location, termintator_type, leader1_pts );
          //Adding extension lines
          Dtk_tab<Dtk_pnt> extension_line_1;
          extension_line_1.push_back( Dtk_pnt( 100., 25. ) );
          extension_line_1.push_back( Dtk_pnt( 100., 0. ) );
          leader1->SetExtensionLine( Dtk_Polyline::Create( std::move( extension_line_1 ) ) );
          dimension->AddLeader( leader1 );
 
          //Creating second leader
          Dtk_transfo leader2_pos;
          leader2_pos.setOrigin( Dtk_pnt( 0., 23., 0. ) );
          Dtk_tab<Dtk_pnt> leader2_pts;
          //Setting the Arrow location
          Dtk_pnt leader2_arrow_location = Dtk_pnt( -100., 23., 0. );
          leader2_pts.push_back( Dtk_pnt( -10., 23., 0. ) );
          //Creating the second leader itself
          Dtk_LeaderPtr leader2 = Dtk_Leader::Create( arrow_width, arrow_length, leader2_arrow_location, termintator_type, leader2_pts );
          //Adding extension lines
          Dtk_tab<Dtk_pnt> extension_line_2;
          extension_line_2.push_back( Dtk_pnt( -100., 25. ) );
          extension_line_2.push_back( Dtk_pnt( -100., 0. ) );
          leader2->SetExtensionLine( Dtk_Polyline::Create( std::move( extension_line_2 ) ) );
          dimension->AddLeader( leader2 );
 
          //  General data of the FDT : position, color, name ..
          Dtk_transfo fdt_transf;
          fdt_transf.setOrigin( Dtk_pnt( 0., 200., 75. ) );
          fdt_transf.setXdir( 0., 1., 0. );
          fdt_transf.setYdir( -1., 0., 0. );
          fdt->Transform( fdt_transf );
 
          Dtk_InfoPtr fdt_info = Dtk_Info::Create();
          fdt_info->SetColor( 0, 255, 0 );
          fdt_info->SetName( "Dimension:1" );
          fdt->info() = fdt_info;
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of myfdt", L"Value of myfdt" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          fdt->info()->SetMetaData( ArrayMetadataEntity );
 
          return fdt;
     }

CreateEsquisse2D()

Dtk_BodyPtr sampleWriter::CreateEsquisse2D

(

)

Creates a 2D wireframe sketch body (planar, lying in the XY plane) containing lines, arc circles, circles, ellipses, and arc ellipses.

Creates a 2D wireframe sketch body (planar, XY plane) containing lines, arcs, circles, and ellipses.

     {
          Dtk_tab<Dtk_CurvePtr> ArrayCurve;
          Dtk_tab<Dtk_PointPtr> ArrayPoint;
 
          Dtk_PointPtr mypoint;
          mypoint = Dtk_Point::Create( Dtk_pnt( 1.0, 2.0, 0.0 ) );
          ArrayPoint.push_back( mypoint );
 
          Dtk_LinePtr line = Dtk_Line::Create( Dtk_pnt( 0.000000, 0.0, 0.0 ), Dtk_pnt( 1.0, 0.0, 0.0 ) );
          ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( line ) );
          line = Dtk_Line::Create( Dtk_pnt( 1.0, 1.0, 0.0 ), Dtk_pnt( 0.0, 1.0, 0.0 ) );
          ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( line ) );
 
          Dtk_EllipsePtr myarccircle;
          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 );
          myarccircle->SetTrimmingParameters( -1.0 * DTK_PI / 2.0, DTK_PI / 2.0 );
          ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myarccircle ) );
 
          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 );
          myarccircle->SetTrimmingParameters( DTK_PI / 2.0, 3.0 * DTK_PI / 2.0 );
          Dtk_NurbsCurvePtr nurbs = myarccircle->ToNurbs();
          ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( nurbs ) );
 
          Dtk_EllipsePtr mycircle;
          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 );
          ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( mycircle ) );
 
          Dtk_EllipsePtr myellipse;
          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 );
          ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
 
          Dtk_EllipsePtr myarcellipse;
          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 );
          myarcellipse->SetTrimmingParameters( -1.0 * DTK_PI / 2.0, DTK_PI / 2.0 );
          ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myarcellipse ) );
 
          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 );
          myarcellipse->SetTrimmingParameters( DTK_PI / 2.0, 3.0 * DTK_PI / 2.0 );
          ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myarcellipse ) );
 
 
          Dtk_BodyPtr mybody;
          mybody = Dtk_Body::Create();
 
          Dtk_ShellPtr myshell;
          myshell = Dtk_Shell::Create( mybody );
 
          myshell->AddWire( ArrayPoint );
          myshell->AddWire( ArrayCurve );
 
          mybody->AddWireShell( myshell );
 
          mybody->info() = Dtk_Info::Create();
          mybody->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
          mybody->info()->SetName( L"CreateEsquisse2D" );
 
          Dtk_transfo transfo;
          transfo.setOrigin( -100.0, 0.0, 0.0 );
          transfo.setScale( 10.0 );
          mybody->Transform( transfo );
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of esquisse2d", L"Value of esquisse2d" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          mybody->info()->SetMetaData( ArrayMetadataEntity );
 
          return mybody;
     }

CreateEsquisse3D()

Dtk_BodyPtr sampleWriter::CreateEsquisse3D

(

)

Creates a 3D wireframe sketch body containing points, lines, NURBS splines, circles, arc circles, ellipses, and arc ellipses.

Creates a 3D wireframe sketch body containing points, lines, circles, arc circles, ellipses, arc ellipses, and NURBS.

     {
          Dtk_Size_t NbPoint = 2;
          Dtk_Size_t NbLine = 2;
          Dtk_Size_t Nbspline = 2;
          Dtk_Size_t NbCircle = 2;
          Dtk_Size_t NbArcCircle = 2;
          Dtk_Size_t NbEllipse = 2;
          Dtk_Size_t NbArcEllipse = 2;
 
 
          Dtk_tab<Dtk_PointPtr> ArrayPoint;
          Dtk_tab<Dtk_CurvePtr> ArrayCurve;
 
 
          for( Dtk_Size_t i = 0; i < NbPoint; i++ )
          {
               Dtk_PointPtr mypoint;
               mypoint = Dtk_Point::Create( Dtk_pnt( -10.0 + 10 * i, 2.0, 12.0 ) );
               mypoint->info() = Dtk_Info::Create();
               mypoint->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
               Dtk_string name( L"mypoint" );
               name.add_int( ( int )i );
               mypoint->info()->SetName( name );
               ArrayPoint.push_back( mypoint );
          }
 
 
          Dtk_tab<Dtk_LinePtr> arraylineptr;
          for( Dtk_Size_t i = 0; i < NbLine; i++ )
          {
               Dtk_LinePtr line = Dtk_Line::Create( Dtk_pnt( -10.0 + 10 * i, 3, 10.0 ), Dtk_pnt( -10.0 + 10 * i, 9, 0.0 ) );
               ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( line ) );
          }
 
          for( Dtk_Size_t i = 0; i < Nbspline; i++ )
          {
               //add nurbs curve
               Dtk_EllipsePtr myellipse;
               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 );
               Dtk_NurbsCurvePtr nurbs = myellipse->ToNurbs();
               ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( nurbs ) );
          }
 
          for( Dtk_Size_t i = 0; i < NbCircle; i++ )
          {
               //add nurbs curve
               Dtk_EllipsePtr myellipse;
               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 );
               ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
          }
 
          for( Dtk_Size_t i = 0; i < NbArcCircle; i++ )
          {
               //add nurbs curve
               Dtk_EllipsePtr myellipse;
               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 );
               myellipse->SetTrimmingParameters( 0.0, DTK_PI );
               ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
          }
 
          for( Dtk_Size_t i = 0; i < NbEllipse; i++ )
          {
               Dtk_EllipsePtr myellipse;
               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 );
               ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
          }
 
          for( Dtk_Size_t i = 0; i < NbArcEllipse; i++ )
          {
               Dtk_EllipsePtr myellipse;
               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 );
               myellipse->SetTrimmingParameters( 0.0, DTK_PI );
               ArrayCurve.push_back( Dtk_CurvePtr::DtkDynamicCast( myellipse ) );
          }
 
          Dtk_BodyPtr mybody;
          mybody = Dtk_Body::Create();
 
          Dtk_ShellPtr myshell;
          myshell = Dtk_Shell::Create( mybody );
 
          myshell->AddWire( ArrayPoint );
          myshell->AddWire( ArrayCurve );
 
          mybody->AddWireShell( myshell );
 
          mybody->info() = Dtk_Info::Create();
          mybody->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
          mybody->info()->SetName( L"CreateEsquisse3D" );
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of esquisse3d", L"Value of esquisse3d" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          mybody->info()->SetMetaData( ArrayMetadataEntity );
 
          return mybody;
     }

CreateFdtDatum()

Dtk_FdtPtr sampleWriter::CreateFdtDatum

(

)

Creates simple Datum.

Creates a simple datum FDT symbol ("A") with a leader, frame, and white text.

     {
          Dtk_FdtPtr fdt = Dtk_Fdt::Create();
 
          //  Creation of Leader line
          Dtk_pnt arrow_location( 0., 0. );
          Dtk_tab<Dtk_pnt> leader_points;
          leader_points.push_back( Dtk_pnt( 0., 18. ) );
          //Creation of leader with terminator's height and width 2.0. The terminator is a filled triangle
          Dtk_LeaderPtr leader = Dtk_Leader::Create( 2.0, 2.0, arrow_location, Dtk_Leader::TerminatorTypeClosedArrow, leader_points );
          //Creation of symbol
          Dtk_SymbolPtr symbol = Dtk_Symbol::Create();
 
          //  Creation of Text info
          Dtk_InfoPtr text_info = Dtk_Info::Create();
          //Setting text color to blue
          text_info->SetColor( 0, 0, 255 );
          //Setting text style
          Dtk_bool horiz_vert = 0, mirror = 0, font_index = 0;
          double slant = 0.;
          Dtk_TextStyle text_style;
          //Text height
          text_style.CharHeight() = 3.5;
          //Text width
          text_style.CharWidth() = 2.1;
          //Text slant
          text_style.Slant() = slant;
 
          //Text value : "A"
          Dtk_string str( "A" );
          //Creating text 2D Bounding box
          Dtk_pnt location( -2., 20. );
          double XLen = 5., YLen = 5.;
          Dtk_dir XDir( 1., 0., 0. ), YDir( 0., 0., 1. );
          Dtk_Oriented2dBBox inbox( location, XLen, YLen, XDir, YDir );
 
          Dtk_anchor_type dtk_align = DTK_ANCHOR_MIDDLE_CENTER;
          DTK_Text_type text_type = dtk_text_type_value;
 
          //Creating the text itself giving :
          //      - its value
          //      - inside and outside boxes
          //      - anchor type
          //      - text type
          //      - horizontal/vertical text orientation
          //      - text infos 
          //      - text style
          //      - text slant - PI / 2.0 for normal text -
          //      - font index
          //      - mirroring type
          Dtk_Text dtk_text( str, inbox, inbox, dtk_align, text_type, horiz_vert, text_info, text_style, slant, font_index, mirror );
 
          //Adding created text to symbol
          Dtk_CompositeText& texts = symbol->Texts();
          texts.AddText( dtk_text );
 
          //Creating the frame of the text
          Dtk_tab< Dtk_CurvePtr > FrameGeoms;
          Dtk_PolylinePtr framePolyline;
          framePolyline = Dtk_Polyline::Create( Dtk_pnt( -5., 18. ), Dtk_pnt( 5., 18. ) );
          framePolyline->AddPoint( Dtk_pnt( 5., 28. ) );
          framePolyline->AddPoint( Dtk_pnt( -5., 28. ) );
          framePolyline->AddPoint( Dtk_pnt( -5., 18. ) );
          FrameGeoms.push_back( Dtk_CurvePtr::DtkDynamicCast( framePolyline ) );
          //Setting the type of the frame
          symbol->SetFrameType( DTK_FRAME_TYPE_RECTANGLE, FrameGeoms );
 
          //  Creation of leader line
          Dtk_InfoPtr leader_info = Dtk_Info::Create();
          leader_info->SetColor( 255, 255, 255 );
          leader->GetInfo() = leader_info;
          //Adding leader to symbol
          symbol->AddLeader( leader );
          //Setting symbol type
          symbol->SymbolType() = Dtk_Symbol::TypeDatum;
          //Adding symbol to FDT
          fdt->Sub2DEntity() = Dtk_2dEntityPtr::DtkDynamicCast( symbol );
 
          //Adding transformation on FDT
          Dtk_transfo fdt_transf;
          fdt_transf.setOrigin( Dtk_pnt( 50., 100., 50. ) );
          fdt->Transform( fdt_transf );
 
          //Adding infos on FDT (Name and color)
          Dtk_InfoPtr fdt_info = Dtk_Info::Create();
          fdt_info->SetColor( 255, 255, 255 );
          fdt_info->SetName( "Datum:1" );
          fdt->info() = fdt_info;
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mydatum", L"Value of mydatum" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          fdt->info()->SetMetaData( ArrayMetadataEntity );
 
          return fdt;
     }

CreateGeometricalTolerance()

Dtk_FdtPtr sampleWriter::CreateGeometricalTolerance

(

)

Creates a geometric tolerance FDT: cylindricity position tolerance | 0.02(M) | A |.

Creates a geometric tolerance FDT (cylindricity tolerance) with a leader and frame.

     {
          Dtk_FdtPtr fdt = Dtk_Fdt::Create();
          // first create and populate the dimension
          //  Creation of Text info
          Dtk_InfoPtr text_info = Dtk_Info::Create();
          //Setting text style
          Dtk_bool horiz_vert = 0, mirror = 0, font_index = 0;
          double slant = 0.;
          Dtk_TextStyle text_style;
          Dtk_dir x_dir( 1, 0, 0 ), normal_dir( 0, 0, 1 );
          //Text height
          text_style.CharHeight() = 3.5;
          //Text width
          text_style.CharWidth() = 2.1;
          //Text slant
          text_style.Slant() = slant;
          Dtk_anchor_type dtk_align = DTK_ANCHOR_BOTTOM_LEFT;
 
 
 
 
          // Create boxes for Container Text  
          Dtk_pnt location_c( 0.0, 0.0 );
          Dtk_Oriented2dBBox container_box( location_c, 15, 15, x_dir, normal_dir );// to give frame box
          Dtk_Oriented2dBBox container_boxin = container_box; // to give inner smaller box for text
          container_boxin.Extend( -2., -2. ); //reduce the initial box
 
 
          //Create Dtk_GeometricalTolerance
          Dtk_GeometricalTolerancePtr MyGeometricalTolerance = Dtk_GeometricalTolerance::Create();
 
          //Create Dtk_ToleranceSpecification
          Dtk_ToleranceSpecificationPtr FirstTolSpec = Dtk_ToleranceSpecification::Create();
 
          //Create Dtk_ToleranceSpecificationContainer 
          Dtk_ToleranceSpecificationContainerPtr MyContainer = Dtk_ToleranceSpecificationContainer::Create( Dtk_ToleranceSpecificationContainer::TypePosition, container_boxin, container_box );
          MyGeometricalTolerance->AddToleranceSpecificationContainer( MyContainer );
 
 
          //Create Fulltext for tolerance
 
          // Create tolerance
          Dtk_CompositeText fulltext;
          Dtk_Text val;
          Dtk_pnt location_v( 15.0, 0.0 );
          Dtk_Oriented2dBBox container_boxv( location_v, 20, 15, x_dir, normal_dir );
          Dtk_Oriented2dBBox container_boxvin = container_boxv;
          container_boxvin.Extend( -2., -2. );
 
 
          val = Dtk_Text( L"0.02", container_boxvin, container_boxv, dtk_align, DTK_Text_type::dtk_text_type_value, horiz_vert, text_info, text_style, slant, font_index, mirror );
          fulltext.AddText( val );
 
          // Create modifier
          Dtk_pnt locationm( 35.0, 0.0 );
          Dtk_Oriented2dBBox container_boxm( locationm, 15, 15, x_dir, normal_dir );
          Dtk_Oriented2dBBox container_boxmin = container_boxm;
          container_boxmin.Extend( -2., -2. );
 
          Dtk_Text modifier = Dtk_Text( L"\u24C2", container_boxmin, container_boxm, dtk_align, DTK_Text_type::dtk_text_type_modifier, horiz_vert, text_info, text_style, slant, font_index, mirror );
          fulltext.AddText( modifier );
 
          // Create Reference Frame
          Dtk_ReferenceFramePtr RefFrame = Dtk_ReferenceFrame::Create();
 
          //Add A
          Dtk_pnt locationA( 50.0, 0.0 );
          Dtk_Oriented2dBBox container_boxA( locationA, 15, 15, x_dir, normal_dir );
          Dtk_Oriented2dBBox container_boxAin = container_boxA;
          container_boxAin.Extend( -2., -2. );
 
 
          Dtk_ReferenceBlockPtr A_Block = Dtk_ReferenceBlock::Create( container_boxAin, container_boxA );
          A_Block->AddReference( L"A" );
          RefFrame->AddReferenceBlock( A_Block );
 
          // Create Dtk_ToleranceSpecificationPtr
          Dtk_ToleranceSpecificationPtr MyToleranceSpecification = Dtk_ToleranceSpecification::Create( val, RefFrame );
          MyToleranceSpecification->SetMainValue( fulltext );
 
          //Add it to Container
          MyContainer->AddToleranceSpecification( MyToleranceSpecification );
 
          fdt->Sub2DEntity() = Dtk_2dEntityPtr::DtkDynamicCast( MyGeometricalTolerance );
 
 
          Dtk_InfoPtr fdt_info = Dtk_Info::Create();
          fdt_info->SetColor( 255, 255, 255 );
          fdt_info->SetName( "GeometricalTolerance" );
          fdt->info() = fdt_info;
 
          return fdt;
     }

CreateInfinitePlane()

Dtk_BodyPtr sampleWriter::CreateInfinitePlane

(

)

Creates a reference body flagged as an infinite plane (InfiniteGeometryFlag + RefEntityFlag), with color and metadata.

Creates a reference plane flagged as infinite , with color and metadata.

     {
          Dtk_BodyPtr mybody = Dtk_Body::Create();
          mybody->info() = Dtk_Info::Create();
          mybody->info()->SetInfiniteGeometryFlag( DTK_TRUE );
          mybody->get_info()->SetRefEntityFlag( DTK_TRUE );
 
          mybody->info()->SetColor( Dtk_RGB( 255, 0, 0, 255 ) );
          mybody->info()->SetName( L"myplan" );
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of myplan", L"Value of myplan" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          mybody->info()->SetMetaData( ArrayMetadataEntity );
 
          Dtk_PlaneSurfacePtr plane = Dtk_PlaneSurface::Create( Dtk_pnt( -11, -12, -13 ), Dtk_dir( 0, 0, 1 ), Dtk_dir( 0, 1, 0 ) );
          Dtk_Double64 dom[ 4 ];
          dom[ 0 ] = 0.0;
          dom[ 1 ] = 10.0;
          dom[ 2 ] = 0.0;
          dom[ 3 ] = 10.0;
 
          plane->SetTrimUVBox( dom );
 
          mybody->AddUnboundedFace( Dtk_SurfacePtr::DtkDynamicCast( plane ) );
 
          return mybody;
     }

CreateMeshCube()

Dtk_MeshPtr sampleWriter::CreateMeshCube

(

)

Mesh Cube sample.

Creates a unit cube triangulated mesh (12 triangles, 24 vertices with normals).

     {
          // Variables
          Dtk_tab<Dtk_pnt>              vertices;
          Dtk_tab<Dtk_dir>              normals;
          Dtk_tab<Dtk_UInt32>           indices;
          Dtk_tab<Dtk_Float32>         uCoords;
          Dtk_tab<Dtk_Float32>         vCoords;
 
          // Our mesh
          Dtk_mesh* outCubeMesh = new Dtk_mesh( DTK_MESH_XYZ | DTK_MESH_NORMAL | DTK_MESH_UV_TEXTURES /*if you have materials*/ ); // coords & normals & materials
 
          // PART1 : CREATING GEOMETRY AND UV COORDINATES ARRAYS (HARD CODED here)
          CreateMeshCubeGeometry( vertices, normals, uCoords, vCoords );
 
 
          // PART2 : STORING geometry (vertices & normals) into the mesh
 
          for( Dtk_Size_t i = 0; i < vertices.size(); i++ )
          {
               outCubeMesh->add_vertex( &( vertices.at( i ) ), &( normals.at( i ) ), NULL, uCoords[ i ], vCoords[ i ] );
          }
 
          // At this point, vertices & normals are stored, but we have no faces yet
 
          // PART3 : BUILDING THE SIX FACES
          CreateMeshCubeFaces( outCubeMesh );
 
          Dtk_RGB rgb( 255, 0, 0 );
          outCubeMesh->set_mesh_color( rgb );  // red cube
          outCubeMesh->info() = Dtk_Info::Create();
          outCubeMesh->info()->SetColor( rgb );
 
          return outCubeMesh;
     }

CreateMeshCubeVertexColor()

Dtk_MeshPtr sampleWriter::CreateMeshCubeVertexColor

(

)

Creates a unit cube mesh with per-vertex color data (red, green, blue, white cycling per face).

Creates a unit cube mesh with per-vertex color data.

     {
          // Variables
          Dtk_tab<Dtk_pnt>              vertices;
          Dtk_tab<Dtk_dir>              normals;
          Dtk_tab<Dtk_Float32>         uCoords;
          Dtk_tab<Dtk_Float32>         vCoords;
          Dtk_RGB red( 255, 0, 0 );
          Dtk_RGB green( 0, 255, 0 );
          Dtk_RGB blue( 0, 0, 255 );
          Dtk_RGB  all( 255, 255, 255 );
 
          // Our mesh
          Dtk_mesh* outCubeMesh = new Dtk_mesh( DTK_MESH_XYZ | DTK_MESH_NORMAL | DTK_MESH_RGB ); // coords & normals & vertex colors
 
          // PART1 : CREATING GEOMETRY ARRAYS (HARD CODED here)
          CreateMeshCubeGeometry( vertices, normals, uCoords, vCoords );
 
          // PART2 : STORING geometry (vertices & normals & vertex color) into the mesh
 
          for( Dtk_Size_t i = 0; i < vertices.size(); i += 4 )
          {
 
               outCubeMesh->add_vertex( &( vertices.at( i ) ), &( normals.at( i ) ), &red );
               outCubeMesh->add_vertex( &( vertices.at( i + 1 ) ), &( normals.at( i + 1 ) ), &green );
               outCubeMesh->add_vertex( &( vertices.at( i + 2 ) ), &( normals.at( i + 2 ) ), &blue );
               outCubeMesh->add_vertex( &( vertices.at( i + 3 ) ), &( normals.at( i + 3 ) ), &all );
          }
 
          // At this point, vertices & normals are stored, but we have no faces yet
 
          // PART3 : BUILDING THE SIX FACES
          CreateMeshCubeFaces( outCubeMesh );
 
          return outCubeMesh;
     }

CreateMeshCuboid()

Dtk_MeshPtr sampleWriter::CreateMeshCuboid	(	const Dtk_pnt &	inFirstPoint,
		const Dtk_pnt &	inSecondPoint
	)

Creates an axis-aligned cuboid mesh from two opposite corner points.

Creates a cuboid (axis-aligned box) mesh from two opposite corner points.

     {
          // Variables
          Dtk_tab<Dtk_pnt>              vertices;
          Dtk_tab<Dtk_dir>              normals;
          Dtk_tab<Dtk_UInt32>           indices;
          Dtk_tab<Dtk_Float32>         uCoords;
          Dtk_tab<Dtk_Float32>         vCoords;
 
          // Our mesh
          Dtk_mesh* outCuboidMesh = new Dtk_mesh( DTK_MESH_XYZ | DTK_MESH_NORMAL | DTK_MESH_UV_TEXTURES /*if you have materials*/ ); // coords & normals & materials
 
          Dtk_pair<Dtk_pnt, Dtk_pnt> inPoints = Dtk_pair<Dtk_pnt, Dtk_pnt>();
          inPoints.first = inFirstPoint;
          inPoints.second = inSecondPoint;
 
          // PART1 : CREATING GEOMETRY AND UV COORDINATES ARRAYS (HARD CODED here)
          CreateMeshCubeidGeometry( vertices, normals, uCoords, vCoords, inPoints );
 
          // PART2 : STORING geometry (vertices & normals) into the mesh
 
          for( Dtk_Size_t i = 0; i < vertices.size(); i++ )
          {
               outCuboidMesh->add_vertex( &( vertices.at( i ) ), &( normals.at( i ) ), NULL, uCoords[ i ], vCoords[ i ] );
          }
 
          // At this point, vertices & normals are stored, but we have no faces yet
 
          // PART3 : BUILDING THE SIX FACES
          CreateMeshCubeFaces( outCuboidMesh );
 
          Dtk_RGB rgb( 255, 0, 0 );
          outCuboidMesh->set_mesh_color( rgb );  // red cube
          outCuboidMesh->info() = Dtk_Info::Create();
          outCuboidMesh->info()->SetColor( rgb );
 
          return outCuboidMesh;
     }

CreateMeshCylinder()

Dtk_MeshPtr sampleWriter::CreateMeshCylinder

(

int

nbpoints

)

Mesh Cylinder sample.

Creates a cylinder mesh with circular caps and lateral surface, tessellated with the given number of circle points.

     {
          // Variables
          Dtk_mesh_face* face = NULL;
          Dtk_tab<Dtk_pnt>              vertices;
          Dtk_tab<Dtk_dir>              normals;
          Dtk_tab<Dtk_UInt32>           indices;
 
          if( nbpoints < 3 )
          {
               return NULL;
          }
 
          // Our mesh
          Dtk_mesh* outCylinderMesh = new Dtk_mesh( DTK_MESH_XYZ | DTK_MESH_NORMAL ); // coords & normals 
 
          Dtk_Size_t i;
          double radius = 3;
          double height = 5;
          for( i = 0; i < ( Dtk_Size_t )nbpoints; i++ )
          {
               double angle = i * 2 * DTK_PI / nbpoints;
               normals.push_back( Dtk_pnt( cos( angle ), sin( angle ), 0 ) );
               vertices.push_back( radius * Dtk_pnt( cos( angle ), sin( angle ) ) + Dtk_pnt( 0, 0, height ) );
               normals.push_back( Dtk_pnt( cos( angle ), sin( angle ), 0 ) );
               vertices.push_back( radius * Dtk_pnt( cos( angle ), sin( angle ), 0 ) );
               indices.push_back( ( Dtk_UInt32 )indices.size() );
               indices.push_back( ( Dtk_UInt32 )indices.size() );
          }
          indices.push_back( 0 );
          indices.push_back( 1 );
 
          face = new Dtk_mesh_face( outCylinderMesh );
          face->add_triangle_strip( &indices, &vertices, &normals );
          outCylinderMesh->add_mesh_face( face );
 
          Dtk_RGB rgb( 255, 255, 0, 128 );
          outCylinderMesh->set_mesh_color( rgb );  // yellow transparent cylinder
          outCylinderMesh->info() = Dtk_Info::Create();
          outCylinderMesh->info()->SetColor( rgb );
 
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mymesh", L"Value of mymesh" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          outCylinderMesh->info()->SetMetaData( ArrayMetadataEntity );
 
          return outCylinderMesh;
     }

CreateMeshPoints()

Dtk_MeshPtr sampleWriter::CreateMeshPoints

(

)

Points mesh sample.

Creates a point cloud mesh.

     {
          Dtk_mesh* outPointMesh = new Dtk_mesh( DTK_MESH_XYZ ); // coords 
          outPointMesh->info() = Dtk_Info::Create();
          outPointMesh->info()->SetColor( Dtk_RGB( 255, 100, 0 ) );
          Dtk_mesh_face* face = new Dtk_mesh_face( outPointMesh );
          double coords[ 8 ][ 3 ] = { {-1,-1,-1},{-1,-1,1},{-1,1,-1},{-1,1,1},
               {1,-1,-1},{1,-1,1},{1,1,-1},{1,1,1} };
          int i;
          for( i = 0; i < 8; i++ )
          {
               Dtk_pnt P( coords[ i ][ 0 ], coords[ i ][ 1 ], coords[ i ][ 2 ] );
               outPointMesh->add_vertex( &P );
               face->add_point( i );
          }
          outPointMesh->add_mesh_face( face );
          return outPointMesh;
     }

CreateMeshWire()

Dtk_MeshPtr sampleWriter::CreateMeshWire

(

)

Wire mesh sample.

Creates a wireframe (polyline) mesh.

     {
          // Variables
          Dtk_mesh_face* face = NULL;
          Dtk_tab<Dtk_pnt>              vertices;
          Dtk_tab<Dtk_dir>              normals;
          Dtk_tab<Dtk_UInt32>           indices;
          Dtk_Size_t i, numVertices;
          Dtk_InfoPtr info = NULL;
 
          // Our mesh
          Dtk_mesh* outWireMesh = new Dtk_mesh( DTK_MESH_XYZ ); // coords 
 
          face = new Dtk_mesh_face( outWireMesh );
 
          //free curves
          vertices.push_back( Dtk_pnt( -1.0f, 1.0f, 1.0f ) );  //0.,1.,0.
          vertices.push_back( Dtk_pnt( -1.0f, 1.0f, -1.0f ) );
          vertices.push_back( Dtk_pnt( 1.0f, 1.0f, -1.0f ) );
          vertices.push_back( Dtk_pnt( 1.0f, 1.0f, 1.0f ) );
 
          numVertices = vertices.size();
          for( i = 0; i < numVertices; i++ )
          {
               indices.push_back( ( Dtk_UInt32 )i );
          }
          indices.push_back( 0 );
 
          info = Dtk_Info::Create();
          info->SetColor( Dtk_RGB( 0, 0, 255 ) );
          face->add_polyline( &indices, &vertices );
          face->add_subinfo( info );
          outWireMesh->add_mesh_face( face );
 
          //free vertex
          info = NULL;
          info = Dtk_Info::Create();
          vertices.clear();
          indices.clear();
          face = new Dtk_mesh_face( outWireMesh );
          vertices.push_back( Dtk_pnt( 0.0f, 1.0f, 0.0f ) );
          indices.push_back( 0 );
          info->SetColor( Dtk_RGB( 255, 0, 0 ) );
          face->add_points( &indices, &vertices );
          face->add_subinfo( info );
          outWireMesh->add_mesh_face( face );
 
          return outWireMesh;
     }

CreateMixedBody()

Dtk_BodyPtr sampleWriter::CreateMixedBody

(

)

Creates a mixed body combining a closed BRep cube (solid) with additional free surfaces and wireframe curves in the same body.

Creates a body combining both BRep faces and wireframe curves in a single body.

     {
          Dtk_BodyPtr body = CreateCube();
 
          Dtk_CylindricalSurfacePtr cyl = Dtk_CylindricalSurface::Create( Dtk_pnt( -20.0, -20.0, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 10.0 );
          Dtk_Double64 domain[] = { 0.0,6.0,0.0,100.0 };
          cyl->SetTrimUVBox( domain );
          cyl->info() = Dtk_Info::Create();
          cyl->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
          body->AddUnboundedFace( Dtk_SurfacePtr::DtkDynamicCast( cyl ) );
 
 
          cyl = Dtk_CylindricalSurface::Create( Dtk_pnt( -20.0, 20.0, 0.0 ), Dtk_dir( 0.0, 0.0, 1.0 ), Dtk_dir( 1.0, 0.0, 0.0 ), 10.0 );
          Dtk_Double64 domain2[] = { 0.0,3.14,-50.0,50.0 };
          cyl->SetTrimUVBox( domain2 );
          cyl->info() = Dtk_Info::Create();
          cyl->info()->SetColor( Dtk_RGB( 0, 255, 0 ) );
          body->AddUnboundedFace( Dtk_SurfacePtr::DtkDynamicCast( cyl ) );
 
          return body;
     }

CreateModelDisplayActivated()

Dtk_ModelDisplayPtr sampleWriter::CreateModelDisplayActivated

(

)

Creates an activated (visible) model display "MyView1" with a perspective camera.

Creates an activated model display (visible view state).

     {
          Dtk_ModelDisplayPtr resMD;
          Dtk_pnt from = Dtk_pnt( 300, 300, 300 );
          Dtk_pnt to( 0, 0, 0 );
          Dtk_pnt up = Dtk_dir( -0.57735, 0.57735, -0.57735 );
          Dtk_CameraPtr cam = Dtk_Camera::Create( from, to, 250, 250, up );
          resMD = Dtk_ModelDisplay::Create( cam, NULL, DTK_TRUE );// create activated model display
          resMD->info() = Dtk_Info::Create();
          resMD->info()->SetName( "MyView1" );
          return resMD;
     }

CreateModelDisplayDesactivated()

Dtk_ModelDisplayPtr sampleWriter::CreateModelDisplayDesactivated

(

)

Creates a deactivated (hidden) model display "MyView2" with an orthographic camera.

Creates a deactivated model display (hidden view state with section).

     {
          Dtk_ModelDisplayPtr resMD;
          Dtk_pnt from( 0, 0, 100 );
          Dtk_pnt to( 0, 0, 0 );
          Dtk_dir up( 0, 1, 0 );
          Dtk_CameraPtr cam = Dtk_Camera::Create( from, to, 100, 100, up );  // semiwidth = 100
          resMD = Dtk_ModelDisplay::Create( cam, NULL, DTK_FALSE ); // create desactivated model display
          resMD->info() = Dtk_Info::Create();
          resMD->info()->SetName( "MyView2" );
          return resMD;
     }

CreateModelDisplayWithSection()

Dtk_ModelDisplayPtr sampleWriter::CreateModelDisplayWithSection

(

)

Creates a deactivated model display "MySectionView" with a section cut plane applied.

Creates a model display with an active section cut plane.

     {
          Dtk_ModelDisplayPtr resMD;
          Dtk_PlaneSurfacePtr section = Dtk_PlaneSurface::Create( Dtk_pnt(), Dtk_dir( 0.75, -0.4, 0. ), Dtk_dir( 0., 0., 1. ) );
          Dtk_ModelDisplayPtr mv1 = CreateModelDisplayActivated();
          resMD = Dtk_ModelDisplay::Create( mv1->GetCamera(), Dtk_EntityPtr::DtkDynamicCast( section ), DTK_FALSE ); // create second desactivated view with section
          resMD->info() = Dtk_Info::Create();
          resMD->info()->SetName( "MySectionView" );
 
          return resMD;
     }

CreateOpenShell()

Dtk_BodyPtr sampleWriter::CreateOpenShell

(

)

Creates an open shell body containing a single trimmed cylindrical surface (half cylinder, not closed).

Creates an open shell body (a trimmed cylindrical surface).

     {
          Dtk_BodyPtr body = Dtk_Body::Create();                  // create the Body
          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 );
          Dtk_Double64 domain[] = { 0.0,3.14,-5.0,5.0 };
          cyl->SetTrimUVBox( domain );
          body->AddUnboundedFace( Dtk_SurfacePtr::DtkDynamicCast( cyl ) );
 
          //For an open shell you can also create an OpenShell and call
          //body->AddOpenShell(shell);
 
          return body;
     }

CreateOpenShell_2()

Dtk_BodyPtr sampleWriter::CreateOpenShell_2

(

)

Creates an open shell body (trimmed cylindrical surface) augmented with open-shell attributes.

Creates an open shell body (5 faces) augmented with open-shell validation properties.

     {
          Dtk_BodyPtr body = Dtk_Body::Create();                  // create the Body
          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 );
          Dtk_Double64 domain[] = { 0.0,3.14,-5.0,5.0 };
          cyl->SetTrimUVBox( domain );
          body->AddUnboundedFace( Dtk_SurfacePtr::DtkDynamicCast( cyl ) );
 
          //For an open shell you can also create an OpenShell and call
          //body->AddOpenShell(shell);
 
          return body;
     }

CreatePoint()

Dtk_BodyPtr sampleWriter::CreatePoint

(

)

Creates a wireframe body containing a single named red point with metadata.

Creates a wireframe body containing a single named point with color and metadata.

     {
          Dtk_tab<Dtk_PointPtr> mypoints;
          Dtk_BodyPtr mybody;
          mybody = Dtk_Body::Create();
 
          Dtk_ShellPtr myshell;
          myshell = Dtk_Shell::Create( mybody );
 
          Dtk_PointPtr mypoint;
          mypoint = Dtk_Point::Create( Dtk_pnt( -10.0, 11.0, 12.0 ) );
          mypoint->info() = Dtk_Info::Create();
          mypoint->info()->SetColor( Dtk_RGB( 255, 0, 0 ) );
          mypoint->info()->SetName( "mypoint" );
 
          Dtk_MetaDataPtr metadata = Dtk_MetaData::CreateMetaData( Dtk_MetaData::TypeProperty, L"Title of mypoint", L"Value of mypoint" );
          Dtk_tab<Dtk_MetaDataPtr> ArrayMetadataEntity;
          ArrayMetadataEntity.push_back( metadata );
          mypoint->info()->SetMetaData( ArrayMetadataEntity );
 
          mypoints.push_back( mypoint );
 
          myshell->AddWire( mypoints );
          mybody->AddWireShell( myshell );
          return mybody;
     }

CreateTexturedMeshCube()

Dtk_MeshPtr sampleWriter::CreateTexturedMeshCube

(

const Dtk_string &

inImageDirectory

)

Textured Mesh Cube sample.

Creates a unit cube mesh with UV texture coordinates, referencing an image from the given directory.

     {
          // Our mesh
          Dtk_MeshPtr outCubeMesh = CreateMeshCube();
 
          // create mesh texture with cubical mapping
          Dtk_RenderInfosPtr meshRender = Dtk_RenderInfos::Create( "meshRender" );
          Dtk_TextureInfosPtr meshTexture = Dtk_TextureInfos::Create( Dtk_TextureInfos::CubicalMapping );
          meshTexture->SetImagePath( inImageDirectory + "sample.bmp" );
          meshTexture->SetScale( 2., 2. ); // image scale
          meshRender->SetTexture( meshTexture );
          outCubeMesh->info()->AddRenderInfos( meshRender ); // apply texture to mesh
          outCubeMesh->info()->SetName( "TexturedMesh" );
 
          // create face render texture
          Dtk_RenderInfosPtr faceRender = Dtk_RenderInfos::Create( "faceRender" );
          Dtk_TextureInfosPtr faceTexture = Dtk_TextureInfos::Create( Dtk_TextureInfos::CubicalMapping );
          faceTexture->SetImagePath( inImageDirectory + "logodtk.bmp" );
          faceTexture->SetScale( 2., 2. ); // image scale
          faceRender->SetTexture( faceTexture );
          if( outCubeMesh->get_mesh_face( 2 )->info().IsNULL() )
               outCubeMesh->get_mesh_face( 2 )->info() = Dtk_Info::Create();
          outCubeMesh->get_mesh_face( 2 )->info()->AddRenderInfos( faceRender ); // apply texture to face
 
          return outCubeMesh;
     }

FillFacesColors()

void sampleWriter::FillFacesColors

(

Dtk_MeshPtr &

inoutCubeMesh

)

Filling mesh faces with colors.

Applies distinct per-face colors to an existing cube mesh (modifies the mesh in place).

     {
          Dtk_InfoPtr infoFace0 = Dtk_Info::Create();
          infoFace0->SetColor( Dtk_RGB( 255, 1, 0 ) );
          inoutCubeMesh->get_mesh_face( 0 )->info() = infoFace0;
 
          Dtk_InfoPtr infoFace1 = Dtk_Info::Create();
          infoFace1->SetColor( Dtk_RGB( 0, 255, 0 ) );
          inoutCubeMesh->get_mesh_face( 1 )->info() = infoFace1;
 
          Dtk_InfoPtr infoFace2 = Dtk_Info::Create();
          infoFace2->SetColor( Dtk_RGB( 0, 0, 255 ) );
          inoutCubeMesh->get_mesh_face( 2 )->info() = infoFace2;
 
          Dtk_InfoPtr infoFace3 = Dtk_Info::Create();
          infoFace3->SetColor( Dtk_RGB( 255, 255, 0 ) );
          inoutCubeMesh->get_mesh_face( 3 )->info() = infoFace3;
 
          Dtk_InfoPtr infoFace4 = Dtk_Info::Create();
          infoFace4->SetColor( Dtk_RGB( 0, 255, 255 ) );
          inoutCubeMesh->get_mesh_face( 4 )->info() = infoFace4;
 
          Dtk_InfoPtr infoFace5 = Dtk_Info::Create();
          infoFace5->SetColor( Dtk_RGB( 255, 128, 0 ) );
          inoutCubeMesh->get_mesh_face( 5 )->info() = infoFace5;
     }