int main( void ) {
// The registry contains information about types present in the current schema; SchemaInit is a function in the schema-specific SDAI library
Registry * registry = new Registry( SchemaInit );
// The InstMgr holds instances that have been created or that have been loaded from a file
InstMgr * instance_list = new InstMgr();
// Increment FileId so entities start at #1 instead of #0.
instance_list->NextFileId();
// STEPfile takes care of reading and writing Part 21 files
STEPfile * sfile = new STEPfile( *registry, *instance_list, "", false );
registry->ResetSchemas();
registry->ResetEntities();
// Build file header
InstMgr * header_instances = sfile->HeaderInstances();
SdaiFile_name * fn = ( SdaiFile_name * ) sfile->HeaderDefaultFileName();
header_instances->Append( ( SDAI_Application_instance * ) fn, completeSE );
fn->name_( "'outfile.stp'" );
fn->time_stamp_( "''" );
fn->author_()->AddNode( new StringNode( "''" ) );
fn->organization_()->AddNode( new StringNode( "''" ) );
fn->preprocessor_version_( "''" );
fn->originating_system_( "''" );
fn->authorization_( "''" );
SdaiFile_description * fd = ( SdaiFile_description * ) sfile->HeaderDefaultFileDescription();
header_instances->Append( ( SDAI_Application_instance * ) fd, completeSE );
fd->description_()->AddNode( new StringNode( "''" ) );
fd->implementation_level_( "'1'" );
SdaiFile_schema * fs = ( SdaiFile_schema * ) sfile->HeaderDefaultFileSchema();
header_instances->Append( ( SDAI_Application_instance * ) fs, completeSE );
fs->schema_identifiers_()->AddNode( new StringNode( "'CONFIG_CONTROL_DESIGN'" ) );
// Build file data. The entities have been created and added in order such that no entity
// references a later entity. This is not required, but has been done to give a logical
// flow to the source and the resulting STEP file.
// Stand-in date and time.
SdaiDate_and_time * date_time = DateTime( registry, instance_list );
// Global units and tolerance.
STEPcomplex * context = Geometric_Context( registry, instance_list, MM, DEG, "0.0001" );
// Primary coordinate system.
SdaiAxis2_placement_3d * orig_transform = DefaultAxis( registry, instance_list );
// Basic context through product and shape representation
SdaiApplication_context * app_context = ( SdaiApplication_context * ) registry->ObjCreate( "APPLICATION_CONTEXT" );
instance_list->Append( ( SDAI_Application_instance * ) app_context, completeSE );
app_context->application_( "'configuration controlled 3d designs of mechanical parts and assemblies'" );
SdaiMechanical_context * mech_context = ( SdaiMechanical_context * ) registry->ObjCreate( "MECHANICAL_CONTEXT" );
instance_list->Append( ( SDAI_Application_instance * ) mech_context, completeSE );
mech_context->name_( "''" );
mech_context->discipline_type_( "'mechanical'" );
mech_context->frame_of_reference_( app_context );
SdaiApplication_protocol_definition * app_protocol = ( SdaiApplication_protocol_definition * ) registry->ObjCreate( "APPLICATION_PROTOCOL_DEFINITION" );
instance_list->Append( ( SDAI_Application_instance * ) app_protocol, completeSE );
app_protocol->status_( "'international standard'" );
app_protocol->application_protocol_year_( 1994 );
app_protocol->application_interpreted_model_schema_name_( "'config_control_design'" );
app_protocol->application_( app_context );
SdaiDesign_context * design_context = ( SdaiDesign_context * ) registry->ObjCreate( "DESIGN_CONTEXT" );
instance_list->Append( ( SDAI_Application_instance * ) design_context, completeSE );
design_context->name_( "''" );
design_context->life_cycle_stage_( "'design'" );
design_context->frame_of_reference_( app_context );
SdaiProduct * prod = ( SdaiProduct * ) registry->ObjCreate( "PRODUCT" );
instance_list->Append( ( SDAI_Application_instance * ) prod, completeSE );
prod->id_( "''" );
prod->name_( "'prodname'" );
prod->description_( "''" );
prod->frame_of_reference_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) mech_context ) );
SdaiProduct_related_product_category * prodcat = ( SdaiProduct_related_product_category * ) registry->ObjCreate( "PRODUCT_RELATED_PRODUCT_CATEGORY" );
instance_list->Append( ( SDAI_Application_instance * ) prodcat, completeSE );
prodcat->name_( "'assembly'" );
prodcat->description_( "''" );
prodcat->products_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod ) );
SdaiProduct_definition_formation_with_specified_source * prod_def_form = ( SdaiProduct_definition_formation_with_specified_source * ) registry->ObjCreate( "PRODUCT_DEFINITION_FORMATION_WITH_SPECIFIED_SOURCE" );
instance_list->Append( ( SDAI_Application_instance * ) prod_def_form, completeSE );
prod_def_form->id_( "''" );
prod_def_form->description_( "''" );
prod_def_form->of_product_( prod );
prod_def_form->make_or_buy_( Source__made );
SdaiProduct_definition * prod_def = ( SdaiProduct_definition * ) registry->ObjCreate( "PRODUCT_DEFINITION" );
instance_list->Append( ( SDAI_Application_instance * ) prod_def, completeSE );
prod_def->id_( "''" );
prod_def->description_( "''" );
prod_def->frame_of_reference_( design_context );
prod_def->formation_( prod_def_form );
SdaiProduct_definition_shape * pshape = ( SdaiProduct_definition_shape * ) registry->ObjCreate( "PRODUCT_DEFINITION_SHAPE" );
instance_list->Append( ( SDAI_Application_instance * ) pshape, completeSE );
pshape->name_( "''" );
pshape->description_( "'ProductShapeDescription'" );
pshape->definition_( new SdaiCharacterized_definition( new SdaiCharacterized_product_definition( prod_def ) ) );
SdaiShape_representation * shape_rep = ( SdaiShape_representation * ) registry->ObjCreate( "SHAPE_REPRESENTATION" );
instance_list->Append( ( SDAI_Application_instance * ) shape_rep, completeSE );
shape_rep->name_( "''" ); // Document?
shape_rep->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) orig_transform ) );
shape_rep->context_of_items_( ( SdaiRepresentation_context * ) context );
SdaiShape_definition_representation * shape_def_rep = ( SdaiShape_definition_representation * ) registry->ObjCreate( "SHAPE_DEFINITION_REPRESENTATION" );
instance_list->Append( ( SDAI_Application_instance * ) shape_def_rep, completeSE );
shape_def_rep->definition_( pshape );
shape_def_rep->used_representation_( shape_rep );
// Stand-in person and org.
SdaiPerson * person = ( SdaiPerson * ) registry->ObjCreate( "PERSON" );
instance_list->Append( ( SDAI_Application_instance * ) person, completeSE );
person->id_( "''" );
person->last_name_( "'Doe'" );
person->first_name_( "'John'" );
SdaiOrganization * org = ( SdaiOrganization * ) registry->ObjCreate( "ORGANIZATION" );
instance_list->Append( ( SDAI_Application_instance * ) org, completeSE );
org->id_( "''" );
org->name_( "''" );
org->description_( "''" );
SdaiPerson_and_organization * per_org = ( SdaiPerson_and_organization * ) registry->ObjCreate( "PERSON_AND_ORGANIZATION" );
instance_list->Append( ( SDAI_Application_instance * ) per_org, completeSE );
per_org->the_person_( person );
per_org->the_organization_( org );
// Required roles.
SdaiPerson_and_organization_role * creator_role = ( SdaiPerson_and_organization_role * ) registry->ObjCreate( "PERSON_AND_ORGANIZATION_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) creator_role, completeSE );
creator_role->name_( "'creator'" );
SdaiPerson_and_organization_role * owner_role = ( SdaiPerson_and_organization_role * ) registry->ObjCreate( "PERSON_AND_ORGANIZATION_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) owner_role, completeSE );
owner_role->name_( "'design_owner'" );
SdaiPerson_and_organization_role * supplier_role = ( SdaiPerson_and_organization_role * ) registry->ObjCreate( "PERSON_AND_ORGANIZATION_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) supplier_role, completeSE );
supplier_role->name_( "'design_supplier'" );
// Basic approval.
SdaiApproval_status * approval_status = ( SdaiApproval_status * ) registry->ObjCreate( "APPROVAL_STATUS" );
instance_list->Append( ( SDAI_Application_instance * ) approval_status, completeSE );
approval_status->name_( "'approved'" );
SdaiApproval * approval = ( SdaiApproval * ) registry->ObjCreate( "APPROVAL" );
instance_list->Append( ( SDAI_Application_instance * ) approval, completeSE );
approval->status_( approval_status );
approval->level_( "''" );
SdaiApproval_date_time * app_date_time = ( SdaiApproval_date_time * ) registry->ObjCreate( "APPROVAL_DATE_TIME" );
instance_list->Append( ( SDAI_Application_instance * ) app_date_time, completeSE );
app_date_time->date_time_( new SdaiDate_time_select( date_time ) );
app_date_time->dated_approval_( approval );
SdaiApproval_role * app_role = ( SdaiApproval_role * ) registry->ObjCreate( "APPROVAL_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) app_role, completeSE );
app_role->role_( "'approver'" );
SdaiApproval_person_organization * app_per_org = ( SdaiApproval_person_organization * ) registry->ObjCreate( "APPROVAL_PERSON_ORGANIZATION" );
instance_list->Append( ( SDAI_Application_instance * ) app_per_org, completeSE );
app_per_org->person_organization_( new SdaiPerson_organization_select( per_org ) );
app_per_org->authorized_approval_( approval );
app_per_org->role_( app_role );
// Basic Classification.
SdaiSecurity_classification * clas = Classification( registry, instance_list, per_org, date_time, prod_def_form );
// Basic CC approval.
SdaiCc_design_approval * desapproval = ( SdaiCc_design_approval * ) registry->ObjCreate( "CC_DESIGN_APPROVAL" );
instance_list->Append( ( SDAI_Application_instance * ) desapproval, completeSE );
desapproval->assigned_approval_( approval );
desapproval->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def ) );
desapproval->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def_form ) );
desapproval->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) clas ) );
SdaiCc_design_person_and_organization_assignment * creatorpersonorg = ( SdaiCc_design_person_and_organization_assignment * ) registry->ObjCreate( "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT" );
instance_list->Append( ( SDAI_Application_instance * ) creatorpersonorg, completeSE );
creatorpersonorg->assigned_person_and_organization_( per_org );
creatorpersonorg->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def ) );
creatorpersonorg->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def_form ) );
creatorpersonorg->role_( creator_role );
SdaiCc_design_person_and_organization_assignment * supplierpersonorg = ( SdaiCc_design_person_and_organization_assignment * ) registry->ObjCreate( "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT" );
instance_list->Append( ( SDAI_Application_instance * ) supplierpersonorg, completeSE );
supplierpersonorg->assigned_person_and_organization_( per_org );
supplierpersonorg->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def_form ) );
supplierpersonorg->role_( supplier_role );
SdaiDate_time_role * datetimerole = ( SdaiDate_time_role * ) registry->ObjCreate( "DATE_TIME_ROLE" );
instance_list->Append( ( SDAI_Application_instance * ) datetimerole, completeSE );
datetimerole->name_( "'creation_date'" );
SdaiCc_design_date_and_time_assignment * assign = ( SdaiCc_design_date_and_time_assignment * ) registry->ObjCreate( "CC_DESIGN_DATE_AND_TIME_ASSIGNMENT" );
instance_list->Append( ( SDAI_Application_instance * ) assign, completeSE );
assign->assigned_date_and_time_( date_time );
assign->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod_def ) );
assign->role_( datetimerole );
SdaiCc_design_person_and_organization_assignment * ownerpersonorg = ( SdaiCc_design_person_and_organization_assignment * ) registry->ObjCreate( "CC_DESIGN_PERSON_AND_ORGANIZATION_ASSIGNMENT" );
instance_list->Append( ( SDAI_Application_instance * ) ownerpersonorg, completeSE );
ownerpersonorg->assigned_person_and_organization_( per_org );
ownerpersonorg->items_()->AddNode( new EntityNode( ( SDAI_Application_instance * ) prod ) );
ownerpersonorg->role_( owner_role );
sfile->WriteExchangeFile( "outfile.stp" );
if( sfile->Error().severity() < SEVERITY_USERMSG ) {
sfile->Error().PrintContents( cout );
}
header_instances->DeleteInstances();
instance_list->DeleteInstances();
delete registry;
delete instance_list;
delete sfile;
printf( "Done!\n" );
}
int main() {
// This has to be done before anything else. This initializes
// all of the registry information for the schema you are using.
// The SchemaInit() function is generated by exp2cxx... see
// extern statement above.
Registry * registry = new Registry( SchemaInit );
// The nifty thing about the Registry is that it basically keeps a list
// of everything in your schema. What this means is that we can go
// through the Registry and instantiate, say, one of everything, without
// knowing at coding-time what entities there are to instantiate. So,
// this test could be linked with other class libraries produced from
// other schema, rather than the example, and run happily.
InstMgr instance_list;
// Here's what's going to happen below: we're going to figure out
// how many different entities there are, instantiate one of each and
// keep an array of pointers to each. We'll stick some random data in
// them as we go. When we're done, we'll print out everything by walking
// the array, and then write out the STEPfile information to the screen.
// Figure outhow many entities there are, then allocate an array
// to store a pointer to one of each.
int num_ents = registry->GetEntityCnt();
STEPentity ** SEarray = new STEPentity*[num_ents];
// "Reset" the Schema and Entity hash tables... this sets things up
// so we can walk through the table using registry->NextEntity()
registry->ResetSchemas();
registry->ResetEntities();
// Print out what schema we're running through.
const SchemaDescriptor * schema = registry->NextSchema();
cout << "Entities in schema " << schema->Name() << ":\n";
// "Loop" through the schema, building one of each entity type.
const EntityDescriptor * ent; // needs to be declared const...
for ( int i = 0; i < num_ents; i++ ) {
ent = registry->NextEntity();
// Build object, using its name, through the registry
SEarray[i] = registry->ObjCreate( ent->Name() );
// Add each realized entity to the instance list
instance_list.Append( SEarray[i], completeSE );
// Put some data into each instance
PrintEntity( SEarray[i] );
}
// Print out all entities
SEarrIterator SEitr( ( const STEPentity ** ) SEarray, num_ents );
exit( 0 );
}
int
main(int argc, char *argv[])
{
int ret = 0;
int convert_tops_list = 0;
struct directory **paths;
int path_cnt = 0;
AP203_Contents *sc = new AP203_Contents;
// process command line arguments
int c;
char *output_file = (char *)NULL;
while ((c = bu_getopt(argc, argv, "o:")) != -1) {
switch (c) {
case 'o':
output_file = bu_optarg;
break;
default:
usage();
bu_exit(1, NULL);
break;
}
}
if (bu_optind >= argc || output_file == (char *)NULL) {
usage();
bu_exit(1, NULL);
}
argc -= bu_optind;
argv += bu_optind;
/* check our inputs/outputs */
if (bu_file_exists(output_file, NULL)) {
bu_exit(1, "ERROR: refusing to overwrite existing output file:\"%s\". Please remove file or change output file name and try again.", output_file);
}
if (!bu_file_exists(argv[0], NULL) && !BU_STR_EQUAL(argv[0], "-")) {
bu_exit(2, "ERROR: unable to read input \"%s\" .g file", argv[0]);
}
if (argc < 2) {
convert_tops_list = 1;
}
std::string iflnm = argv[0];
std::string oflnm = output_file;
/* load .g file */
BRLCADWrapper *dotg = new BRLCADWrapper();
if (!dotg) {
std::cerr << "ERROR: unable to create BRL-CAD instance" << std::endl;
return 3;
}
if (!dotg->load(iflnm)) {
std::cerr << "ERROR: unable to open BRL-CAD input file [" << oflnm << "]" << std::endl;
delete dotg;
return 2;
}
struct db_i *dbip = dotg->GetDBIP();
struct rt_wdb *wdbp = wdb_dbopen(dbip, RT_WDB_TYPE_DB_DISK);
if (convert_tops_list) {
/* Need db_update_nref for DB_LS_TOPS to work */
db_update_nref(dbip, &rt_uniresource);
path_cnt = db_ls(dbip, DB_LS_TOPS, &paths);
if (!path_cnt) {
std::cerr << "ERROR: no objects found in .g file" << "\n" << std::endl;
delete dotg;
return 1;
}
} else {
int i = 1;
paths = (struct directory **)bu_malloc(sizeof(struct directory *) * argc, "dp array");
while (i < argc) {
bu_log("%d: %s\n", i, argv[i]);
struct directory *dp = db_lookup(dbip, argv[i], LOOKUP_QUIET);
if (dp == RT_DIR_NULL) {
std::cerr << "ERROR: cannot find " << argv[i] << "\n" << std::endl;
delete dotg;
bu_free(paths, "free path memory");
return 1;
} else {
paths[i-1] = dp;
path_cnt++;
i++;
}
}
paths[i-1] = RT_DIR_NULL;
}
struct bu_vls scratch_string;
bu_vls_init(&scratch_string);
Registry *registry = new Registry(SchemaInit);
InstMgr instance_list;
STEPfile *sfile = new STEPfile(*registry, instance_list);
registry->ResetSchemas();
registry->ResetEntities();
/* Populate the header instances */
InstMgr *header_instances = sfile->HeaderInstances();
/* 1 - Populate File_Name */
SdaiFile_name * fn = (SdaiFile_name *)sfile->HeaderDefaultFileName();
bu_vls_sprintf(&scratch_string, "'%s'", output_file);
fn->name_(bu_vls_addr(&scratch_string));
fn->time_stamp_("");
StringAggregate_ptr author_tmp = new StringAggregate;
author_tmp->AddNode(new StringNode("''"));
fn->author_(author_tmp);
StringAggregate_ptr org_tmp = new StringAggregate;
org_tmp->AddNode(new StringNode("''"));
fn->organization_(org_tmp);
fn->preprocessor_version_("'BRL-CAD g-step exporter'");
fn->originating_system_("''");
fn->authorization_("''");
header_instances->Append((SDAI_Application_instance *)fn, completeSE);
/* 2 - Populate File_Description */
SdaiFile_description * fd = (SdaiFile_description *)sfile->HeaderDefaultFileDescription();
StringAggregate_ptr description_tmp = new StringAggregate;
description_tmp->AddNode(new StringNode("''"));
fd->description_(description_tmp);
fd->implementation_level_("'2;1'");
header_instances->Append((SDAI_Application_instance *)fd, completeSE);
/* 3 - Populate File_Schema */
SdaiFile_schema *fs = (SdaiFile_schema *)sfile->HeaderDefaultFileSchema();
StringAggregate_ptr schema_tmp = new StringAggregate;
schema_tmp->AddNode(new StringNode("'CONFIG_CONTROL_DESIGN'"));
fs->schema_identifiers_(schema_tmp);
header_instances->Append((SDAI_Application_instance *)fs, completeSE);
sc->registry = registry;
sc->instance_list = &instance_list;
sc->default_context = Add_Default_Geometric_Context(sc);
sc->application_context = (SdaiApplication_context *)sc->registry->ObjCreate("APPLICATION_CONTEXT");
sc->instance_list->Append((STEPentity *)sc->application_context, completeSE);
sc->application_context->application_("'CONFIGURATION CONTROLLED 3D DESIGNS OF MECHANICAL PARTS AND ASSEMBLIES'");
sc->design_context = (SdaiDesign_context *)sc->registry->ObjCreate("DESIGN_CONTEXT");
sc->instance_list->Append((STEPentity *)sc->design_context, completeSE);
sc->design_context->name_("''");
sc->design_context->life_cycle_stage_("'design'");
sc->design_context->frame_of_reference_(sc->application_context);
sc->solid_to_step = new std::map<struct directory *, STEPentity *>;
sc->solid_to_step_shape = new std::map<struct directory *, STEPentity *>;
sc->solid_to_step_manifold = new std::map<struct directory *, STEPentity *>;
sc->comb_to_step = new std::map<struct directory *, STEPentity *>;
sc->comb_to_step_shape = new std::map<struct directory *, STEPentity *>;
sc->comb_to_step_manifold = new std::map<struct directory *, STEPentity *>;
for (int i = 0; i < path_cnt; i++) {
/* Now, add actual DATA */
struct directory *dp = paths[i];
struct rt_db_internal intern;
rt_db_get_internal(&intern, dp, dbip, bn_mat_identity, &rt_uniresource);
RT_CK_DB_INTERNAL(&intern);
Object_To_STEP(dp, &intern, wdbp, sc);
rt_db_free_internal(&intern);
}
/* Write STEP file */
if (!bu_file_exists(output_file, NULL)) {
std::ofstream stepout(output_file);
sfile->WriteExchangeFile(stepout);
}
/* Free memory */
header_instances->DeleteInstances();
instance_list.DeleteInstances();
delete dotg;
delete registry;
delete sfile;
delete sc->solid_to_step;
delete sc->solid_to_step_shape;
delete sc->solid_to_step_manifold;
delete sc->comb_to_step;
delete sc->comb_to_step_shape;
delete sc->comb_to_step_manifold;
delete sc;
bu_vls_free(&scratch_string);
bu_free(paths, "free dp list");
return ret;
}