LoadBodiesIntoSession.cpp File Reference

Functions
void	ActivatePsMemory (bool inActivate)
void	ActivatePsSession (bool inActivate)
void	ActivatePsTraverse (bool inActivate)
void	EnumerateBodiesInSession ()
bool	IsPsMemoryActivated ()
bool	IsPsSessionActivated ()
bool	IsPsTraverseActivated ()
void	LoadBodiesIntoPsSession (const Dtk_string &inXtFile)
void	LoadBodiesIntoPsSessionFromStream (const Dtk_tab< char > &inStream)
static PK_ERROR_code_t	PsErrorHandler (PK_ERROR_sf_t *error_sf)
void	ReceiveBodiesIntoCurrentPsSession (const Dtk_string &inXtFile)
void	ReceiveBodiesIntoCurrentPsSessionFromStream (const Dtk_tab< char > &inStream)
static void	ReceiveBodyFromTempFile (const char *inData, Dtk_Size_t inDataSize, const string &inIndent)
static void	SetPSchema ()
static void	StartPsSession ()
void	StartSharedPsSession ()
static void	StopPsSession ()
void	StopSharedPsSession ()
static void	TraverseNodeBodiesFromStream (Dtk_NodePtr inNode, int inDepth)

Variables
static bool	s_psMemoryActivated = false
static bool	s_psSessionActivated = false
static bool	s_psTraverseActivated = false

Function Documentation

ActivatePsMemory()

void ActivatePsMemory

(

bool

inActivate

)

{ s_psMemoryActivated   = inActivate; }

ActivatePsSession()

void ActivatePsSession

(

bool

inActivate

)

{ s_psSessionActivated  = inActivate; }

ActivatePsTraverse()

void ActivatePsTraverse

(

bool

inActivate

)

{ s_psTraverseActivated = inActivate; }

EnumerateBodiesInSession()

void EnumerateBodiesInSession

(

)

{
    PK_PARTITION_t partition = 0;
    PK_SESSION_ask_curr_partition( &partition );
 
    int nBodies = 0;
    PK_BODY_t* bodies = nullptr;
    PK_PARTITION_ask_bodies( partition, &nBodies, &bodies );
    cout << "Bodies in active partition: " << nBodies << endl;
 
    for( int i = 0; i < nBodies; ++i )
    {
        PK_BODY_t body = bodies[ i ];
 
        PK_BODY_type_t bodyType = 0;
        PK_BODY_ask_type( body, &bodyType );
 
        int nFaces = 0;
        PK_FACE_t* faces = nullptr;
        PK_ERROR_code_t fErr = PK_BODY_ask_faces( body, &nFaces, &faces );
 
        const char* typeName = "unknown";
        if     ( bodyType == PK_BODY_type_solid_c   ) typeName = "solid";
        else if( bodyType == PK_BODY_type_sheet_c   ) typeName = "sheet";
        else if( bodyType == PK_BODY_type_wire_c    ) typeName = "wire";
        else if( bodyType == PK_BODY_type_acorn_c   ) typeName = "acorn";
        else if( bodyType == PK_BODY_type_general_c ) typeName = "general";
 
        if( fErr == PK_ERROR_none )
        {
            cout << "  Body[" << i << "]  tag=" << body
                 << "  type=" << typeName
                 << "  faces=" << nFaces << endl;
            if( faces ) PK_MEMORY_free( faces );
        }
        else
        {
            cout << "  Body[" << i << "]  tag=" << body
                 << "  type=" << typeName
                 << "  PK_BODY_ask_faces error=" << fErr << endl;
        }
    }
 
    if( bodies ) PK_MEMORY_free( bodies );
}

IsPsMemoryActivated()

bool IsPsMemoryActivated

(

)

{ return s_psMemoryActivated;   }

IsPsSessionActivated()

bool IsPsSessionActivated

(

)

{ return s_psSessionActivated;  }

IsPsTraverseActivated()

bool IsPsTraverseActivated

(

)

{ return s_psTraverseActivated; }

LoadBodiesIntoPsSession()

void LoadBodiesIntoPsSession

(

const Dtk_string &

inXtFile

)

{
    cout << "\n--- Parasolid session: loading \""
         << inXtFile.c_str() << "\" from disk ---" << endl;
 
    SetPSchema();
    StartPsSession();
 
    PK_PART_receive_o_t recvOpts;
    PK_PART_receive_o_m( recvOpts );
 
    int nParts  = 0;
    PK_PART_t* parts = nullptr;
    PK_ERROR_code_t pkErr = PK_PART_receive(
        inXtFile.c_str(), &recvOpts, &nParts, &parts );
 
    if( pkErr != PK_ERROR_none )
    {
        cout << "PK_PART_receive failed, error code: " << pkErr << endl;
        StopPsSession();
        return;
    }
    cout << "PK_PART_receive: " << nParts << " part(s) received." << endl;
 
    EnumerateBodiesInSession();
 
    if( parts ) PK_MEMORY_free( parts );
 
    StopPsSession();
    cout << "--- Parasolid session closed ---" << endl;
}

LoadBodiesIntoPsSessionFromStream()

void LoadBodiesIntoPsSessionFromStream

(

const Dtk_tab< char > &

inStream

)

{
    if( inStream.size() == 0 )
    {
        cout << "Warning: in-memory stream is empty, nothing to load." << endl;
        return;
    }
 
    cout << "\n--- Parasolid session: loading "
         << inStream.size() << " bytes from in-memory stream ---" << endl;
 
    SetPSchema();
    StartPsSession();
 
    // Map the Dtk_tab<char> buffer to a single PK_MEMORY_block_t.
    PK_MEMORY_block_t block;
    block.next    = nullptr;
    block.n_bytes = static_cast<size_t>( inStream.size() );
    block.bytes   = &inStream[ 0 ];
 
    PK_PART_receive_o_t recvOpts;
    PK_PART_receive_o_m( recvOpts );
 
    int nParts  = 0;
    PK_PART_t* parts = nullptr;
    PK_ERROR_code_t pkErr = PK_PART_receive_b( block, &recvOpts, &nParts, &parts );
 
    if( pkErr != PK_ERROR_none )
    {
        cout << "PK_PART_receive_b failed, error code: " << pkErr << endl;
        StopPsSession();
        return;
    }
    cout << "PK_PART_receive_b: " << nParts << " part(s) received." << endl;
 
    EnumerateBodiesInSession();
 
    if( parts ) PK_MEMORY_free( parts );
 
    StopPsSession();
    cout << "--- Parasolid session closed ---" << endl;
}

PsErrorHandler()

static PK_ERROR_code_t PsErrorHandler ( PK_ERROR_sf_t *  error_sf )

static

{
    return error_sf->code;
}

ReceiveBodiesIntoCurrentPsSession()

void ReceiveBodiesIntoCurrentPsSession

(

const Dtk_string &

inXtFile

)

{
    cout << "\n--- Receiving \""
         << inXtFile.c_str()
         << "\" into existing Parasolid session ---" << endl;
 
    PK_PART_receive_o_t recvOpts;
    PK_PART_receive_o_m( recvOpts );
 
    int nParts  = 0;
    PK_PART_t* parts = nullptr;
    PK_ERROR_code_t pkErr = PK_PART_receive(
        inXtFile.c_str(), &recvOpts, &nParts, &parts );
 
    if( pkErr != PK_ERROR_none )
    {
        cout << "PK_PART_receive failed, error code: " << pkErr << endl;
        return;
    }
    cout << "PK_PART_receive: " << nParts << " part(s) received." << endl;
 
    if( parts ) PK_MEMORY_free( parts );
}

ReceiveBodiesIntoCurrentPsSessionFromStream()

void ReceiveBodiesIntoCurrentPsSessionFromStream

(

const Dtk_tab< char > &

inStream

)

{
    if( inStream.size() == 0 )
    {
        cout << "Warning: in-memory stream is empty, nothing to receive." << endl;
        return;
    }
 
    cout << "\n--- Receiving "
         << inStream.size()
         << " bytes from in-memory stream into existing Parasolid session ---" << endl;
 
    PK_MEMORY_block_t block;
    block.next    = nullptr;
    block.n_bytes = static_cast<size_t>( inStream.size() );
    block.bytes   = &inStream[ 0 ];
 
    PK_PART_receive_o_t recvOpts;
    PK_PART_receive_o_m( recvOpts );
 
    int nParts  = 0;
    PK_PART_t* parts = nullptr;
    PK_ERROR_code_t pkErr = PK_PART_receive_b( block, &recvOpts, &nParts, &parts );
 
    if( pkErr != PK_ERROR_none )
    {
        cout << "PK_PART_receive_b failed, error code: " << pkErr << endl;
        return;
    }
    cout << "PK_PART_receive_b: " << nParts << " part(s) received." << endl;
 
    if( parts ) PK_MEMORY_free( parts );
}

ReceiveBodyFromTempFile()

static void ReceiveBodyFromTempFile ( const char *  inData, Dtk_Size_t  inDataSize, const string &  inIndent  )

static

{
    Dtk_string tempFile = Dtk_API::GetAPI()->GetWorkingDir();
    tempFile += L"dtk_ps_traverse.x_b";
    tempFile.FixPathSeparator();
 
    FILE* fp = tempFile.OpenFile( DTK_WB );
    if( !fp )
    {
        cout << inIndent << "  Error: cannot write temp file "
             << tempFile.c_str() << endl;
        return;
    }
    fwrite( inData, sizeof(char), static_cast<size_t>( inDataSize ), fp );
    fclose( fp );
 
    // Key string for PK_PART_receive: path without extension.
    Dtk_string realName = tempFile.drive() + tempFile.path() + tempFile.filename();
 
    PK_PART_receive_o_t partOpts;
    PK_PART_receive_o_m( partOpts );
    partOpts.transmit_format = PK_transmit_format_binary_c;
 
    PK_PARTITION_receive_o_t partitionOpts;
    PK_PARTITION_receive_o_m( partitionOpts );
    partitionOpts.transmit_format = PK_transmit_format_binary_c;
 
    int nParts = 0;
    PK_PART_t* parts = nullptr;
 
    PK_ERROR_code_t pkErr = PK_PART_receive(
        realName.c_str(), &partOpts, &nParts, &parts );
 
    if( pkErr == PK_ERROR_corrupt_file )
    {
        // Fallback: file may be a partition (assembly) rather than a single part.
        PK_PARTITION_t partition = 0;
        pkErr = PK_PARTITION_receive(
            realName.c_str(), &partitionOpts, &partition );
        if( pkErr == PK_ERROR_none && partition > 0 )
            pkErr = PK_PARTITION_ask_bodies( partition, &nParts,
                                             (PK_BODY_t**)&parts );
    }
 
    tempFile.unlink();
 
    if( pkErr == PK_ERROR_none )
        cout << inIndent << "  -> " << nParts
             << " body/bodies added to session." << endl;
    else
        cout << inIndent << "  -> PK_PART_receive error: " << pkErr << endl;
 
    if( parts ) PK_MEMORY_free( parts );
}

SetPSchema()

static void SetPSchema ( )

static

{
    Dtk_string schemaDir = "./Schema";
#ifndef Linux
    char fullPath[ _MAX_PATH ];
    if( _fullpath( fullPath, "./Schema", _MAX_PATH ) != nullptr )
        schemaDir = fullPath;
    // Buffer must stay alive for the process lifetime.
    static wchar_t schEnvW[ 2048 ];
    swprintf( schEnvW, 2047, L"P_SCHEMA=%s", schemaDir.w_str() );
    _wputenv( schEnvW );
#else
    static char schEnvA[ 2048 ];
    snprintf( schEnvA, sizeof(schEnvA), "P_SCHEMA=%s", schemaDir.c_str() );
    putenv( schEnvA );
#endif
}

StartPsSession()

static void StartPsSession ( )

static

{
    PK_SESSION_frustrum_t frustrum;
    PK_SESSION_frustrum_o_m( frustrum );
    frustrum.fstart = FSTART;
    frustrum.fabort = FABORT;
    frustrum.fstop  = FSTOP;
    frustrum.fmallo = FMALLO;
    frustrum.fmfree = FMFREE;
    frustrum.ffoprd = FFOPRD;
    frustrum.ffopwr = FFOPWR;
    frustrum.ffclos = FFCLOS;
    frustrum.ffread = FFREAD;
    frustrum.ffwrit = FFWRIT;
    frustrum.goopsg = GOOPSG;
    frustrum.goclsg = GOCLSG;
    frustrum.gosgmt = GOSGMT;
    PK_SESSION_register_frustrum( &frustrum );
 
    PK_SESSION_start_o_t sessionOpts;
    PK_SESSION_start_o_m( sessionOpts );
    sessionOpts.user_field = 16;
    PK_SESSION_start( &sessionOpts );
 
    PK_ERROR_frustrum_t errFrustrum;
    errFrustrum.handler_fn = PsErrorHandler;
    PK_ERROR_register_callbacks( errFrustrum );
 
    PK_SESSION_set_journalling( PK_LOGICAL_true );
    PK_SESSION_set_check_self_int( PK_LOGICAL_false );
    PK_SESSION_set_check_continuity( PK_LOGICAL_false );
 
    PK_SESSION_kernel_version_t ver;
    if( PK_SESSION_ask_kernel_version( &ver ) == PK_ERROR_none )
        cout << "PsKernel version: "
             << ver.major_revision << "."
             << ver.minor_revision << "."
             << ver.build_number   << endl;
}

StartSharedPsSession()

void StartSharedPsSession

(

)

{ SetPSchema(); StartPsSession(); }

StopPsSession()

static void StopPsSession ( )

static

{
    PK_SESSION_stop();
}

StopSharedPsSession()

void StopSharedPsSession

(

)

{ StopPsSession(); }

TraverseNodeBodiesFromStream()

static void TraverseNodeBodiesFromStream ( Dtk_NodePtr  inNode, int  inDepth  )

static

{
    if( inNode.IsNULL() ) return;
 
    int blanked = inNode->GetInfos()->GetBlankedStatus();
    if( blanked == 1 )
    {
        Dtk_Size_t n = inNode->GetNumChildren();
        for( Dtk_Size_t i = 0; i < n; ++i )
            TraverseNodeBodiesFromStream( inNode->GetChild(i), inDepth );
        return;
    }
 
    string indent( static_cast<size_t>( inDepth ) * 2, ' ' );
    Dtk_Node::FullType nodeType = inNode->GetNodeFullType();
 
    if( nodeType.PrimaryType() == Dtk_Node::BodyType
        && inNode->GetInfos()->GetInfiniteGeometryFlag() == 0
        && blanked == 0 )
    {
        Dtk_BodyPtr body = inNode->GetDtk_BodyPtr();
        if( body.IsNotNULL() )
        {
            Dtk_string name;
            if( body->info().IsNotNULL() ) name = body->info()->GetName();
 
            Dtk_Size_t numStreams = body->GetNumStream();
            bool found = false;
            for( Dtk_Size_t s = 0; s < numStreams; ++s )
            {
                Dtk_StreamPtr stream = body->GetStream( s );
                if( stream.IsNotNULL()
                    && stream->GetStreamType() == Dtk_Stream::DTK_STREAM_X_B )
                {
                    const char*      data     = stream->GetBinaryContent();
                    const Dtk_Size_t dataSize = stream->GetBinaryContentSize();
 
                    cout << indent << "[Body]";
                    if( name.len() > 0 ) cout << " \"" << name.c_str() << "\"";
                    cout << "  stream=" << dataSize << " B" << endl;
 
                    ReceiveBodyFromTempFile( data, dataSize, indent );
                    found = true;
                    break;
                }
            }
            if( !found )
            {
                cout << indent << "[Body]";
                if( name.len() > 0 ) cout << " \"" << name.c_str() << "\"";
                cout << "  (no Parasolid stream, skipped)" << endl;
            }
        }
    }
 
    Dtk_Size_t n = inNode->GetNumChildren();
    for( Dtk_Size_t i = 0; i < n; ++i )
        TraverseNodeBodiesFromStream( inNode->GetChild(i), inDepth );
}

Variable Documentation

s_psMemoryActivated

bool s_psMemoryActivated = false

static

s_psSessionActivated

bool s_psSessionActivated = false

static

s_psTraverseActivated

bool s_psTraverseActivated = false

static