Our team is facing significant challenges integrating CAD viewer functionality into approval workflows in Teamcenter 12.4. We need reviewers to visualize 3D models directly within workflow tasks without launching separate CAD applications. The main issues involve data synchronization between viewer sessions and workflow states, and compatibility across different CAD formats (NX, CREO, SolidWorks). We’re exploring options using Teamcenter’s visualization services and open APIs, but we’re uncertain about the best integration approach. How do you handle viewer integration in approval workflows? What strategies work for ensuring data synchronization when reviewers add markup or annotations during workflow reviews? Are there specific API patterns or viewer configuration approaches that improve compatibility across multiple CAD formats?
Teamcenter Visualization (TcVis) embedded in workflow tasks is the primary supported path here. The core architecture relies on Active Workspace Client (AWC) rendering JT translations rather than native CAD formats directly — this is critical to your multi-format compatibility question.
Format Compatibility Strategy
Don’t try to serve NX, CREO, and SolidWorks natively to the viewer. Standardize on JT as the visualization currency:
- Configure NX translator via UGII_TRANSLATOR_DIR settings to auto-publish JT on save/checkin
- CREO requires Creo View MCAD Adapter — verify adapter version compatibility with TC 12.4 in your version
- SolidWorks uses Teamcenter Connector for SolidWorks; JT generation must be triggered explicitly or via dispatcher
Set TC_auto_update_vis_data=true in your tc_profilevars to push JT regeneration on dataset revision (verify in your version).
Workflow Integration — API Pattern
The recommended pattern is hooking Workflow Action Handlers to enforce visualization state before task completion:
<!-- In workflow template, bind a pre-action handler -->
<ActionHandler name="EPM-check-visualization-exists"
action="DO_TASK"
execution_trigger="BEFORE_SIGNOFF">
<arg name="dataset_type" value="DirectModel"/>
<arg name="required" value="true"/>
</ActionHandler>
Use the SOA (Service-Oriented Architecture) layer — specifically Workflow::getTaskDetails and Core::getProperties — to query task state programmatically:
// AWC custom panel — check markup dataset linked to task
TcSoaService.post('Workflow-2014-06', 'getTaskDetails', {
selection: [taskObject]
}).then(response => {
const attachments = response.taskDetails[0].attachments;
// filter for Markup datasets
});
Markup / Annotation Synchronization
Markup datasets (DirectModel + .bcf or .vmk files) are the synchronization artifact. Key configuration points:
- Ensure markup saves back to the Item Revision relation
TC_Attaches, not loose in the workspace - Use
FMS (File Management System)cache settings to prevent stale JT serving —FMS_BYPASS_CACHE=0for review sessions - TcVis Server must be configured with
VIS_SNAPSHOT_ENABLE=trueto persist viewer state across sessions (verify in your version)
For multi-user concurrent markup review, TcVis Collaboration module is required — standard embedded viewer does not support live multi-user sessions without it.
AWC Viewer Configuration (tc-conf.json)
"viewerConfig": {
"preferredViewer": "tcvis",
"autoLoadMarkup": true,
"markupRelation": "TC_Attaches",
"supportedFormats": ["JT", "PLMXML"]
}
Version Compatibility Note
TC 12.4 AWC ships with TcVis 12.x embedded viewer. If you’re on AWC 4.x client against TC 12.4 server, confirm the Visualization Dispatcher build level matches — mismatched dispatcher/server versions are the most common source of broken JT publishing pipelines. Verify exact build alignment in your environment via Help > About in the AWC client.
This draft is based on general Teamcenter knowledge. It has not been verified against your specific version and environment. Practitioners: verify the steps and share your experience below.
We use Teamcenter Visualization Services with embedded viewer components in custom workflow forms. The key is using the JT format as a common visualization format regardless of source CAD system. Configure your workflows to automatically generate JT files during submission, then embed the viewer using the Visualization Services API. This approach handles NX, CREO, and SolidWorks models uniformly.
Data synchronization is critical when reviewers add markups during workflow reviews. We implemented a pattern where viewer annotations are automatically saved as separate dataset objects linked to the workflow task. When the reviewer completes their task, a workflow handler collects all markup datasets and attaches them to the workflow process. This ensures annotations aren’t lost and remain accessible throughout the approval chain. Use the Markup Service API to programmatically capture and persist viewer annotations as workflow progresses through review stages.
For open API integration, focus on the Visualization REST APIs available in TC 12.4. These APIs provide endpoints for viewer session management, model loading, and markup retrieval. We built custom workflow handlers that invoke these APIs to initialize viewer sessions when workflow tasks are opened and to save viewer state when tasks are completed. The REST API approach gives you flexibility to integrate viewers in web-based workflow clients or custom applications. Document the API authentication flow carefully - viewer sessions need proper security tokens to access model data through the workflow context.
Compatibility across CAD formats requires a translation strategy. Don’t try to view native CAD files directly in workflows - performance and compatibility will be inconsistent. Instead, implement automated translation workflows that convert all CAD formats to JT during check-in or release processes. Use Teamcenter’s translator framework to configure format-specific translation jobs. Once everything is in JT format, viewer integration becomes straightforward and consistent regardless of source CAD system. This also improves viewer performance since JT files are optimized for visualization.
Consider the user experience aspect of viewer integration. We embedded lightweight viewer components directly in workflow task forms using the Visualization Services JavaScript API. This allows reviewers to rotate, zoom, and measure models without leaving the workflow interface. For data synchronization, implement auto-save functionality that persists viewer camera positions and markup annotations every few minutes. Use workflow event handlers to capture viewer state during task submission so the next reviewer sees exactly what the previous reviewer was examining.
Integrating CAD viewers into workflows requires addressing technical, compatibility, and synchronization challenges systematically.
Open APIs and Integration Architecture: Teamcenter 12.4 provides two primary API paths for viewer integration: the Visualization Services Java API for server-side integration and the Visualization REST API for web-based implementations. For workflow integration, the REST API approach offers greater flexibility. Implement workflow handlers that initialize viewer sessions using the /visualization/sessions endpoint when reviewers open workflow tasks. Use the session token to load model data via /visualization/models endpoint with the workflow context object ID. The API handles authentication and data access permissions automatically based on workflow participant rights. For markup capture, leverage the /visualization/markups endpoint to retrieve and persist annotations as workflow progresses. Design your integration to handle viewer session timeouts gracefully - implement session refresh logic that maintains viewer state if workflow tasks remain open for extended periods.
Compatibility Strategy Across CAD Formats: Achieve format compatibility through standardized visualization translation rather than attempting direct native CAD file viewing. Configure Teamcenter’s dispatcher framework to automatically trigger JT translation jobs when CAD files are added to workflow processes. Create translation templates for each source format (NX, CREO, SolidWorks) that specify appropriate tessellation quality and metadata preservation settings. Use the Translation Management API to monitor translation job completion before allowing workflow tasks to proceed to review stages. Implement fallback mechanisms where workflows wait for JT generation before notifying reviewers. This ensures all reviewers interact with consistent, optimized visualization data regardless of source CAD system. For legacy models without JT files, create background translation workflows that process existing data progressively.
Data Synchronization and Workflow State Management: Implement robust synchronization between viewer interactions and workflow state using event-driven handlers. Create workflow handlers that subscribe to viewer events like markup creation, camera position changes, and measurement captures. Store viewer state data as JSON objects in workflow process variables so state persists across workflow stages. When reviewers add annotations, automatically create markup dataset objects linked to both the source model and the workflow task. Use workflow sub-processes to aggregate markups from multiple reviewers into consolidated review packages. Implement conflict resolution logic for scenarios where multiple reviewers annotate simultaneously. Design workflows that lock model versions during active review to prevent data synchronization issues from concurrent modifications.
This comprehensive approach ensures seamless viewer integration while maintaining workflow data integrity and cross-format compatibility.