InterOp:Connect/ACIS/Assembly Representation

// ACIS
// ACIS headers
#include "kernapi.hxx"
#include "spl_api.hxx"
#include "cstrapi.hxx"  
#include "intrapi.hxx"
#include "boolapi.hxx"
#include "operapi.hxx"
#include "eulerapi.hxx"
#include "ga_api.hxx"
#include "fileinfo.hxx"
#include "lists.hxx"
#include "alltop.hxx"
#include "savres.hxx"
#include "fileinfo.hxx"
#include "lists.hxx"
#include "kernapi.hxx"
#include "acistype.hxx"
#include "ga_api.hxx"
#include "at_str.hxx"
#include "collection.hxx"
#include "group.hxx"
#include "at_int.hxx"

// System
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if defined(XLINUX) || defined(XSOLARIS) || defined(mac)
#include <wchar.h>
#endif
//-----------------------------------------------------------------------------
//Check InterOp API outcome and prints the error message
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//Start ACIS modeler and initialize required ACIS modules
//-----------------------------------------------------------------------------
logical InitializeAcis ()
{
    outcome res;

    res = api_start_modeller(0);
	if( TRUE == res.ok())
	{
		res  = api_initialize_kernel();
	    res = api_initialize_spline();
		res = api_initialize_intersectors();
	    res = api_initialize_euler_ops();
	    res = api_initialize_constructors();
	    res = api_initialize_generic_attributes();
	    res = api_initialize_booleans();

		// set default FileInfo
	    FileInfo fileInfo;
	    fileInfo.set_product_id("ACIS (c) SPATIAL");
		fileInfo.set_units(1); //model units are assumed to be millimeters
		res = api_set_file_info( FileId | FileUnits ,fileInfo);
	}
	
	return res.ok();
}    

//-----------------------------------------------------------------------------
//Terminate ACIS modules and stop the ACIS modeler
//-----------------------------------------------------------------------------
logical TerminateAcis ()
{
    outcome res;

    res = api_terminate_booleans();
    res = api_terminate_generic_attributes();
    res = api_terminate_constructors();
    res = api_terminate_euler_ops();
    res = api_terminate_intersectors();
    res = api_terminate_spline();
    res = api_terminate_kernel();

    api_stop_modeller();

	return res.ok();
}

logical RestoreSatFile( const char *satFileName, ENTITY_LIST &elist)
{
	logical res = FALSE;

	size_t length	= strlen( satFileName);
	logical textFile = TRUE;
	if( satFileName[ length-1] == 'b')
		textFile = FALSE;

	FILE *fp = fopen( satFileName, textFile ? "rt" : "rb");
	outcome result;
	if( fp)
	{
		result	= api_restore_entity_list( fp, textFile, elist);
		fclose( fp);
		fp = NULL;
		
		res = result.ok() ? TRUE : FALSE;
	}
	

	if( TRUE == res)
		printf("\nFile %s successfully read.\n", satFileName);
	else
		printf("\n*** ERROR ***\tCould not read SAT file: %s\n", satFileName);

	
	return res;
}

//Create a new ACIS SAT file from the supplied ENTITY_LIST
//-----------------------------------------------------------------------------
logical SaveSatFile (ENTITY_LIST elist, const char *fileName)
{
	outcome res;

	FILE *fp = fopen ( fileName, "w");
	if( fp == NULL)
        printf("\tUnable to open file %s for output.\n", fileName);
	else
	{
		res= api_save_entity_list ( fp, TRUE, elist);
		fclose ( fp);
		fp = NULL;

		if( TRUE == res.ok())
	        printf("\nFile %s successfully written.\n", fileName);
		else
	        printf("\n*** ERROR ***\tUnable to save SAT file %s.\n", fileName);
	}

	return res.ok();
}




void printHelp()
{
	printf("Usage : ProcessAssemblyCutFeature.exe -i file -o file\n");
	printf("ProcessAssemblyCutFeature.exe :\n");
	printf("-i		: Input SAT file with assembly cut feature information\n");
	printf("-o		: Output SAT file( after processing cut features)\n");
}


char pszInputFile[256]={'\0'};
char pszOutputFile[256]={'\0'};
// Input argument parser
int getArgs(int argc, char *argv[])
{
	int err=0;

	if(argc <= 1)
	{
		printHelp();
		err = 1;
		return err;
	}

	int i=1;
	while (i<argc)
	{
		if (strcmp("-i", argv[i])==0)
		{
			if (++i<argc)
			{
				strncpy(pszInputFile, argv[i], 256);
			}
			else
			{
				printHelp();
				err=1;
			}
		}
		else if (strcmp("-o", argv[i])==0)
		{
			if (++i<argc)
			{
				strncpy(pszOutputFile, argv[i], 256);
			}
			else
			{
				printHelp();
				err=1;
			}
		}
		i++;
	}

	return err;
}
/*! 
	Returns whether input entity is a cut feature tool
*/
logical IsCutTool( ENTITY * ipEntity)
{
	logical retVal = FALSE;
	if( NULL == ipEntity )
		return retVal;

	ATTRIB_GEN_INTEGER* pCutToolAttrib = NULL;
	outcome	result = api_find_named_attribute( ipEntity, "SPAATTRIB_ASSY_CUT_TOOL", reinterpret_cast< ATTRIB_GEN_NAME*&>( pCutToolAttrib) );
	
	if( pCutToolAttrib && ( result.ok() == TRUE))
	{
		int type = pCutToolAttrib->value();
		retVal = TRUE;
	}
	return retVal;
}

/*! 
	Returns whether input entity is a cut feature
*/
logical IsCutFeature( ENTITY * ipEntity)
{
	logical retVal = FALSE;
	if( NULL == ipEntity || FALSE == is_SPACOLLECTION( ipEntity))
		return retVal;

	ATTRIB_GEN_INTEGER* pGrpType = NULL;
	outcome	result = api_find_named_attribute( ipEntity, "ATTRIB_XACIS_GROUP_TYPE", reinterpret_cast< ATTRIB_GEN_NAME*&>( pGrpType) );
	
	if( pGrpType && ( result.ok() == TRUE))
	{
		int type = pGrpType->value();
		if( 4 == type)
		{
			retVal = TRUE;
		}
	}
	return retVal;
}

/**
 * Gets ATTRIB_XACIS_NAME generic attribute value
 * @param iEnt
 *		Input ENTITY to be queried for ATTRIB_XACIS_NAME attribute
 * @param opName
 *		Output Name of entity
 */
logical GetEntityName( ENTITY * iEnt, char * & opName)
{
	logical retVal = FALSE;
	ATTRIB_GEN_STRING* pName = NULL;
	outcome	result = api_find_named_attribute( iEnt, "ATTRIB_XACIS_NAME", reinterpret_cast< ATTRIB_GEN_NAME*&>( pName) );
	

	opName = NULL;
	if( pName && ( result.ok() == TRUE))
	{
		const char* pTmpStr = pName->value();
		if( pTmpStr && ( result.ok() == TRUE))
		{
			opName = new char [ strlen(pTmpStr) + 1];
			strcpy( opName, pTmpStr);
			retVal = TRUE;
		}
	}
	return retVal;
}
/*!
	Traverses list of entities to find cut features and returns list of cut features
	@param iEntityList
		Input list of entities 
	@param oCutFeatureCollections
		Output list of cut features
	Returns if successful
 */
logical GetCutFeatures( const ENTITY_LIST & iEntityList, ENTITY_LIST & oCutFeatureCollections)
{
	if( 0 == iEntityList.count())
		return FALSE;

	iEntityList.init();
	ENTITY * pEntity = NULL;
	while( NULL != (pEntity = iEntityList.next()))
	{
		if( TRUE == IsCutFeature( pEntity) )
		{
			oCutFeatureCollections.add( pEntity);
		}
	}

	return (oCutFeatureCollections.count() > 0) ? TRUE : FALSE;
}

/*
	Get Assembly Cut feature information
	@param iCutFeatures
		Input list of features (SPACOLLECTIONs)
	@param oCutTools
		Output list of cut tools
	@param oCutTargets
		Output list of cut targets
	Return TRUE if successful
 */

logical GetAssemblyCutInfo( const ENTITY_LIST & iCutFeatures, ENTITY_LIST & oCutTools, ENTITY_LIST & oCutTargets)
{
	if( 0 == iCutFeatures.count())
		return FALSE;

	iCutFeatures.init();
	ENTITY * pEnt = NULL;
	while( NULL != ( pEnt = iCutFeatures.next()))
	{
		if( FALSE == is_SPACOLLECTION( pEnt))
			continue;

		SPACOLLECTION * pCollection = (SPACOLLECTION *)pEnt;
		if( NULL == pCollection)
			continue;
		
		pCollection->init();
		ENTITY * pMember = NULL;
		while( NULL != ( pMember = pCollection->next()) )
		{
			if( TRUE == IsCutTool( pMember))
			{
				oCutTools.add( pMember);
			}
			else if( FALSE == is_SPAGROUP( pMember))
			{
				oCutTargets.add( pMember);
			}
		}
	}
	return TRUE;
}

/*!
	Processes all cut features in input ENTITY LIST (do cut operation)
	@param iEntityList 
		Input list of entities 
	Returns TRUE if successful
 */

logical ProcessAllAssemblyCutFeature( ENTITY_LIST & iEntityList)
{
	logical retVal = FALSE;
	if( 0 == iEntityList.count())
		return FALSE;

	ENTITY_LIST  cutFeatureCollections;
	retVal = GetCutFeatures(iEntityList, cutFeatureCollections);
	if( FALSE == retVal || 0 == cutFeatureCollections.count())
	{
		printf("No assembly cut feature found\n");
		return retVal;
	}
	
	ENTITY_LIST cutTools;
	ENTITY_LIST cutTargets;	
	retVal = GetAssemblyCutInfo( cutFeatureCollections, cutTools, cutTargets);
	
	cutTools.init();
	ENTITY * pTool = NULL;
	while( NULL != ( pTool = cutTools.next()) )
	{
		char * pName = NULL;
		GetEntityName( pTool, pName);
		if( pName)
		{
			printf("Performing Cut operation for feature:%s\n", pName);
			delete [] pName;
		}

		ENTITY * pTarget = NULL;
		cutTargets.init();
		while( NULL != ( pTarget = cutTargets.next()) )
		{
			BODY * pResultBody = NULL;
			BoolOptions * pBoolOpt = NULL;
			AcisOptions * ao       = NULL;
			outcome result = api_boolean( (BODY *)pTool, (BODY *)pTarget, SUBTRACTION, NDBOOL_KEEP_TOOL,pResultBody, pBoolOpt, ao);
		}
		api_del_entity( pTool);
	}

	return retVal;
}

//----------------------------------------------------------------------------------------
void unlock_license();

int main( int argc, char * argv[])
{
	unlock_license();

	int err = 0;
    if ( (err = getArgs(argc, argv) ) !=0)
		return err;
	InitializeAcis();
	
   ENTITY_LIST eList;
   logical res = RestoreSatFile( pszInputFile, eList);

   ProcessAllAssemblyCutFeature( eList);

   SaveSatFile( eList, pszOutputFile);

   if( FALSE == res)
	   return res;

   
   TerminateAcis();
   return 0;
}