CAD4FE_api_sw_tool.h

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       CAD4FE_api_sw_tool.h
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#ifndef CAD4FE_api_sw_toolh
#define CAD4FE_api_sw_toolh
 
#include <vector>              
#include <map>
 
#if defined(USING_ATL)
#include <atl\atlvcl.h>
#endif
#include <Atl/atlbase.h>
#include <Atl/atlmod.h>
#include <SwConst_TLB.h>
#define SW_VERSION 2012
#include <SldWorks_TLB.h>
#include <smartvars.h>
 
#ifdef __BORLANDC__
using namespace Sldworks_tlb;
#endif
 
 
CAD4FE_COMMON_ITEM void   SW_CoCreateInstance(CComPtr<ISldWorks> & __swApp);
CAD4FE_COMMON_ITEM void   SW_ExitApp(CComPtr<ISldWorks> & __swApp);
CAD4FE_COMMON_ITEM void SW_App_CreateBoundaryConditionAttributeDef(CComPtr<ISldWorks> & __swApp, CComPtr <IAttributeDef> & DefAttrConditionLimite);
CAD4FE_COMMON_ITEM int SW_OpenDoc(const CComPtr<ISldWorks> & __swApp, char *filename, CComPtr<IModelDoc2>& __swModel, char __configuration[]="");
CAD4FE_COMMON_ITEM void SW_CloseDoc(CComPtr<IModelDoc2>& __swModel);
CAD4FE_COMMON_ITEM void SW_CloseDoc(const CComPtr<ISldWorks> & __swApp, char *filename);
CAD4FE_COMMON_ITEM void   SW_GetActiveDoc(const CComPtr<ISldWorks> & __swApp, CComPtr<IModelDoc2> &__swModel);
CAD4FE_COMMON_ITEM DWORD WINAPI SW_App_SendMsgToUser_Ok(void * pointerSW);
                                                  
CAD4FE_COMMON_ITEM void SW_RibFeature_GetDefinition(CComPtr<IFeature> __swFeature, CComPtr<IRibFeatureData2> & __swFeatData);
CAD4FE_COMMON_ITEM int SW_Feature_TestAttribute(CComPtr<IFeature> & __swFeature,CComPtr <IAttributeDef> &);
CAD4FE_COMMON_ITEM int SW_Feature_Select(CComPtr<IFeature> __swFeature, CComPtr <ISelectData> __swSelData);
CAD4FE_COMMON_ITEM template <class T>
void SW_Feature_GetDefinition(CComPtr<IFeature> __swFeature, CComPtr<T> & __swFeatData);
CAD4FE_COMMON_ITEM int SW_Feature_Suppress(CComPtr<IModelDoc2> & __swModel, CComPtr<IFeature> & __swFeature);
CAD4FE_COMMON_ITEM void SW_Feature_GetBoundingBox (CComPtr<IModelDoc2> & __swModel, CComPtr<IFeature> & __swFeature, double __bbox[6]);
 
CAD4FE_COMMON_ITEM void
SW_Feature_GetProjectionPlane(CComPtr<IFeature> swFeature, double planeRootPoint[3], double planeNormal[3]);
 
CAD4FE_COMMON_ITEM void
SW_Feature_GetProjectionPlane2(CComPtr<IFeature> __swFeature, CComPtr<IModelDoc2> __swModel, double planeRootPoint[3], double planeNormal[3]);
CAD4FE_COMMON_ITEM void
SW_Feature_GetPoint(CComPtr<IFeature> & pFeature, double xyzFeature[3]);
CAD4FE_COMMON_ITEM bool SW_Feature_IsSuppressed(CComPtr<IModelDoc2> & __swModel, CComPtr<IFeature> & __swFeature);
 
 
CAD4FE_COMMON_ITEM void SW_SimpleFilletFeature_GetDefinition(CComPtr<IFeature> __swFeature, CComPtr<ISimpleFilletFeatureData2> & __swFeatData);
CAD4FE_COMMON_ITEM double SW_SimpleFilletFeatureData_GetRadius( CComPtr<ISimpleFilletFeatureData2> __swFeatData );
CAD4FE_COMMON_ITEM int SW_SimpleFilletFeatureData_GetItemsCount(CComPtr<ISimpleFilletFeatureData2> __swFeatData);
CAD4FE_COMMON_ITEM void SW_SimpleFilletFeatureData_ReleaseSelectionAccess(CComPtr<ISimpleFilletFeatureData2> __swFeatData);
CAD4FE_COMMON_ITEM void SW_SimpleFilletFeatureData_AccessSelections(CComPtr<ISimpleFilletFeatureData2> __swFeatData, CComPtr<IModelDoc2> __swModel);
CAD4FE_COMMON_ITEM std::multimap<int, CComPtr < IEdge > > SW_GetItemEdges(LPUNKNOWN punk_item);
CAD4FE_COMMON_ITEM std::multimap<int, CComPtr < IEdge > > SW_Loop_GetEdges(CComPtr<ILoop2> __swLoop);
CAD4FE_COMMON_ITEM std::multimap<int, CComPtr < IEdge > > SW_Face_GetEdges(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM int SW_Face_GetMaterialProperties(CComPtr <IFace2> & swFace, std::vector <double> & );
CAD4FE_COMMON_ITEM int SW_Face_GetMaterialProperties(CComPtr <IFace2> & swFace, unsigned char rgba[4]);
CAD4FE_COMMON_ITEM double SW_SimpleFilletFeatureData_GetRadiusAtItem(CComPtr<ISimpleFilletFeatureData2> __swFeatData, LPUNKNOWN __item);
CAD4FE_COMMON_ITEM void SW_SimpleFilletFeatureData_GetItemAtIndex(CComPtr<ISimpleFilletFeatureData2> __swFeatData, int __index, LPUNKNOWN & __item);
 
CAD4FE_COMMON_ITEM void SW_ChamferFeature_GetDefinition(CComPtr<IFeature> __swFeature, CComPtr<IChamferFeatureData2> & __swFeatData);  
CAD4FE_COMMON_ITEM void SW_ChamferFeatureData_GetAngleDistance (CComPtr<IChamferFeatureData2> &swFeatData, double * angle, double * distance);
 
 
CAD4FE_COMMON_ITEM void SW_Face_GetBox(CComPtr<IFace2> __swFace, double __bbox[6]);
CAD4FE_COMMON_ITEM void SW_Face_GetBoxTessellation(CComPtr<IFace2> & __swFace, double __bbox[6]);
CAD4FE_COMMON_ITEM long SW_Face_GetLoopCount(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM int SW_Face_TestAttribute(CComPtr<IFace2> & __swFace,CComPtr <IAttributeDef> &);
void
SW_Face_GetProjectionPlane(CComPtr <IFace2> selectedFace1, double __rootPoint[3], double __normal[3]);
 
void
SW_Face_CreateTangentPlaneAtCenter(CComPtr<IModelDoc2> __swModel, CComPtr <IFace2> __swFace, double __rootPoint[3], double __XVector[3], double __normal[3],
CComPtr<IRefPlane> & __swRefPlane );
CAD4FE_COMMON_ITEM int SW_Face_IsRevolved(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM void
SW_Face_ClosetPointOnContour(CComPtr<IFace2> __swFace, double __point[3], double __result[3]);
CAD4FE_COMMON_ITEM int SW_Face_ReverseEvaluate0(CComPtr<IFace2> __swFace, double __pos[3], double __uv[2]);
CAD4FE_COMMON_ITEM void SW_Face_GetCenterPoint(CComPtr<IFace2> __swFace, CComPtr<IModelDoc2> __swModel, double __result[3]);
CAD4FE_COMMON_ITEM
void
SW_Face_GetClosestPointOn(CComPtr<IFace2> __swFace, double __point[3], double __result[3]);
CAD4FE_COMMON_ITEM int SW_Face_GetId(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM int SW_FaceEdge_UVBox (CComPtr <IEdge> edge, CComPtr <IFace2> face, double startUV[2], double endUV[2]);
CAD4FE_COMMON_ITEM int SW_Face_GetUVBounds (CComPtr <IFace2> face, double *bbox);
CAD4FE_COMMON_ITEM bool  SW_Face_IsUPeriodic(CComPtr <IFace2> face);
CAD4FE_COMMON_ITEM bool  SW_Face_IsVPeriodic(CComPtr <IFace2> face);
 
void
CAD4FE_COMMON_ITEM SW_Surface_Parameterization(CComPtr<ISurface> __swSurface, double __uRange[2], double __vRange[2], int __uBoundType[2], int __vBoundType[2], int __uProps[4], int __vProps[4], int __numProps[2]);
 
CAD4FE_COMMON_ITEM
void
SW_FindCommonVertexBetweenTwoAdjacentEdges (CComPtr<IEdge> __swEdge1, CComPtr<IEdge> __swEdge2, CComPtr<IVertex> & __swVertex);
/*
* Get the 3D coordinates and tangent direction of
* the extremities points of the SW edge
*/                                                                                                                                                                                                                          
            // If SenseFlag is TRUE, then the curve and edge are in the same direction.
            // If SenseFlag is FALSE, then the curve and edge are in opposite directions
CAD4FE_COMMON_ITEM int SW_Edge_GetParameters (CComPtr<IEdge> __swEdge, double *__startUParam, double *__endUParam, double *__startPt, double *__endPt, double *__startTanDir, double *__endTanDir,int *_curveType,int *_senseFlag);
CAD4FE_COMMON_ITEM int SW_Edge_Select(CComPtr<IEdge> __swEdge, CComPtr <ISelectData> __swSelData);
CAD4FE_COMMON_ITEM void SW_Edge_GetBody(CComPtr<IEdge> __swEdge, CComPtr<IBody2> & __swBody);
CAD4FE_COMMON_ITEM void SW_Edge_EvaluateAtVertex(CComPtr<IEdge> __swEdge, CComPtr<IVertex> __swVertex, double __point[3], double __tangent[3]);
CAD4FE_COMMON_ITEM int SW_Edge_TestAttribute(CComPtr<IEdge> & __swEdge,CComPtr <IAttributeDef> &);
void  SW_Edge_GetClosestPointOn(CComPtr<IEdge> __swEdge, double __point[3], double __result[3]);
double SW_Edge_GetDistanceToPoint(CComPtr<IEdge> __swEdge, double __point[3]);
CAD4FE_COMMON_ITEM 
void
SW_Edge_GetTangentEdgesPropagation2 (CComPtr <IEdge> __swEdge, std::multimap <int, CComPtr < IEdge > > & __tangentEdges, int & __maxEdgeId);
 
/*
* This function returns the coordinates and the tangent of a point on a
* curve at a specified U parameter
*/
CAD4FE_COMMON_ITEM int SW_Curve_Evaluate(CComPtr <ICurve> curve, double U, double point[3], double tangent[3]);
CAD4FE_COMMON_ITEM long  SW_Curve_GetIdentity(CComPtr<ICurve> __swCurve);
CAD4FE_COMMON_ITEM bool  SW_Curve_IsCircle(CComPtr<ICurve> __swCurve);
CAD4FE_COMMON_ITEM bool  SW_Curve_IsLine(CComPtr<ICurve> __swCurve);
CAD4FE_COMMON_ITEM bool  SW_Curve_IsBspline(CComPtr<ICurve> __swCurve);
 
 
CAD4FE_COMMON_ITEM void  SW_Edge_EvaluateCurvilinearDistancePoint(CComPtr<IEdge> __swEdge,
                CComPtr<IVertex> __swVertex,
                double __L,
                double *__LResult,
                double *__t,
                double __X[3]
                );
 
CAD4FE_COMMON_ITEM void SW_Edge_Tessellate(CComPtr<IEdge> & __swEdge,
                double __startPnt[3],
                double __endPnt[3],
                std::vector<double> & __result);
CAD4FE_COMMON_ITEM void
SW_Edge_Tessellate(CComPtr<IEdge> & __swEdge, double __maxSize, std::vector<double> & __result);
CAD4FE_COMMON_ITEM void
SW_Edge_Tessellate(CComPtr<IEdge> & __swEdge, double __uStart, double __uEnd, std::vector<double> & __result);
 
/* Reverse evaluate the face at a given 3D point
* arg1 : SW face
* arg2 : 3D coordinates of the point to reverse-evaluate
* arg3 : 3D vector to output the normal direction at this point
* arg4 : 3D vector to output the first principal direction
* arg5 : 3D vector to output the second principal direction
* arg6 : 3D vector to output the first principal curvature
* arg7 : 3D vector to output the second principal curvature
*/
CAD4FE_COMMON_ITEM void   SW_Face_EvaluateAtPoint(CComPtr<IFace2> __swFace,
        double __pos[3],
        double* __faceNormal,               // Array of 3 doubles
        double *__firstPrincipalDirection=NULL,  // (optional) Array of 3 doubles
        double *__secondPrincipalDirection=NULL, // (optional)  Array of 3 doubles
        double *__firstPrincipalCurvature=NULL,  // (optional)  pointer to 1 double
        double *__secondPrincipalCurvature=NULL  // (optional)  pointer to 1 double
        );
 
CAD4FE_COMMON_ITEM int SW_Face_Select(CComPtr<IFace2> __swFace, CComPtr <ISelectData> __swSelData);        
void SW_Edge_GetBody(CComPtr<IEdge> __swEdge, CComPtr<IBody2> & __swBody);
 
CAD4FE_COMMON_ITEM void SW_Body_MaxEdgeId(CComPtr<IBody2> __swBody, int * __id);
CAD4FE_COMMON_ITEM void SW_Body_GetBodyBox(CComPtr<IBody2> __swBody, double __bbox[6]);
CAD4FE_COMMON_ITEM void
SW_Body_GetBodyBox(CComPtr<IBody2> __swBody, double __lowerDiagCorner[3], double __upperDiagCorner[3]);
 
CAD4FE_COMMON_ITEM void SW_Edge_SetId(CComPtr <IEdge> __swEdge, int id);
 
CAD4FE_COMMON_ITEM  int SW_Edge_GetId(CComPtr <IEdge> __swEdge);
 
/*
* This function returns the coordinates and the tangent of a point on an
* edge at a specified U parameter
*/
CAD4FE_COMMON_ITEM int SW_Edge_Evaluate(CComPtr<IEdge> edge, double U, double point[3], double tangent[3]);
CAD4FE_COMMON_ITEM int SW_Edge_Evaluate_CheckDomain(CComPtr<IEdge> edge, double U, double point[3], double tangent[3]);
CAD4FE_COMMON_ITEM int SW_Edge_Evaluate_CheckDomain(CComPtr<IEdge> edge, double StartUParam, double EndUParam, double U, double point[3], double tangent[3]);
 
 
/*
* This function gets the closest point from arg2 on the SW edge and
* returns its parametric position (arg3), and 3D tangent direction (arg4)
*/
CAD4FE_COMMON_ITEM void SW_Edge_ReverseEvaluate(CComPtr<IEdge> __swEdge, double __pos[3], double *__u, double __tanDir[3]);
/*
* This function gets the closest point from arg2 on the SW edge and
* returns its parametric position (arg3)
*/
void
SW_Edge_ReverseEvaluate(CComPtr<IEdge> __swEdge, double __pos[3], double *__u);
 
/*
* This function returns the U parametric range of an edge
*/
CAD4FE_COMMON_ITEM void SW_GetEdgeBounds(CComPtr<IEdge> __swEdge, double *__startParam, double *__endParam);
 
/*
* This function returns the U parametric range of an edge
* AND the start and end points !
*/
CAD4FE_COMMON_ITEM void SW_GetEdgeBounds(CComPtr<IEdge> __swEdge, double *__startParam, double *__endParam, double __startPnt[3], double __endPnt[3]);
                 
/*
* this function calculates the curvilinear length of an edge
*/
CAD4FE_COMMON_ITEM double SW_Edge_GetLength(CComPtr<IEdge> __swEdge);
 
/*
* This function the position of the point on the surface at parameters U and V
* its normal, and its tangent directions along U and V iso-parametric curves
*/
CAD4FE_COMMON_ITEM int SW_Surface_Evaluate1(CComPtr<ISurface> surface, double U, double V, double point[3], double DU[3], double DV[3], double normal[3]);
/*
* This function the position of the point on the face at parameters U and V
* its normal, and its tangent directions along U and V iso-parametric curves
*/
CAD4FE_COMMON_ITEM int SW_Surface_Evaluate1(CComPtr<IFace2> face, double U, double V, double point[3], double DU[3], double DV[3], double normal[3]);
 
CAD4FE_COMMON_ITEM void
SW_Face_RandomCreatePoint ( CComPtr<IFace2> __swFace, double __uvBounds[4], double __result[3]);
                         
CAD4FE_COMMON_ITEM void
SW_Face_Evaluate0 ( CComPtr<IFace2> __swFace, double uv[2], double __result[3]);
 
CAD4FE_COMMON_ITEM int SW_Surface_Evaluate2(CComPtr<ISurface> surface,
        double U, double V, double evaluatedPoint[3],
        double DerU[3], double DerV[3], double DerUV[3], double DerUU[3], double DerVV[3],
        double normal[3],
        int *numUDerivs, int *numVDerivs,
        long *surfIdentity);
CAD4FE_COMMON_ITEM int SW_Surface_Evaluate2(CComPtr<IFace2> __swFace,
        double U, double V, double evaluatedPoint[3],
        double DerU[3], double DerV[3], double DerUV[3], double DerUU[3], double DerVV[3],
        double normal[3],
        int *numUDerivs, int *numVDerivs,
        long *surfIdentity);
        
CAD4FE_COMMON_ITEM int SW_Surface_Evaluate3(CComPtr<ISurface> surface,
double U, double V, double evaluatedPoint[3],
double DerU[3], double DerV[3], double DerUV[3], double DerUU[3], double DerVV[3],
double normal[3],
int *numUDerivs, int *numVDerivs,
long surfIdentity = -516);
/*
* This function returns the UV parametric coordinates of the face of a point lying
* on an edge
*/
CAD4FE_COMMON_ITEM int  SW_FaceEdge_ReverseEvaluate(CComPtr<IEdge> edge, CComPtr<IFace2> face, double U, double UV[2]);
 
CAD4FE_COMMON_ITEM double * swEdgeGetTessPts (CComPtr<IEdge> & __swEdge, int *__size,
        double nChordTol             = 0.000001,
        double nLengthTol            = 0.000001);
 
 
CAD4FE_COMMON_ITEM void SW_Sketch_GetPlaneParams(CComPtr<ISketch> & __swSketch,
         double __origin[3], double __normal[3], double __XVector[3]);
 
CAD4FE_COMMON_ITEM void
SW_SketchSegment_GetTessPts (CComPtr<ISketchSegment> & __swSketchSegment, double *__tessPts, int *__size,
        double nChordTol = .001,
        double nLengthTol = .001);
 
CAD4FE_COMMON_ITEM void   SW_Face_GetTessTriangles (CComPtr<IFace2> __swFace, long *__triangleCount, SafeDoubleArray **);
CAD4FE_COMMON_ITEM void SW_Face_GetTessTriangles (CComPtr<IFace2> __swFace, long *__triangleCount, double ** __tessPts);
 
CAD4FE_COMMON_ITEM int SW_CoEdge_GetFaceInteriorDirection(CComPtr<IEdge> __swEdge, CComPtr<IFace2> __swFace, double __X[3], double __D[3]);
 
/*       std::map < int,
                CComPtr < IFace2 >
                >
CAD4FE_COMMON_ITEM SW_GetEdgeFaces(CComPtr<IEdge> __swEdge);*/
void
CAD4FE_COMMON_ITEM SW_GetEdgeFaces(CComPtr<IEdge> __swEdge, CComPtr<IFace2> & __swFace1, CComPtr<IFace2> & __swFace2);
 
CAD4FE_COMMON_ITEM void   SW_EvaluateClosestPointOnFace(CComPtr<IFace2> __swFace,
        double __pos[3],
        double *__facePos,               // Array of 3 doubles
        double *__uParams,              // Array of 1 double
        double *__vParams
        );
 
CAD4FE_COMMON_ITEM void   SW_EvaluateClosestPointOnFace(CComPtr<IFace2> __swFace,
        double __pos[3],
        double *__X3D,               // 3D position
        double *__X2D              // parametric position
        );
CAD4FE_COMMON_ITEM void   SW_EvaluateClosestPointOnSurface(CComPtr<ISurface> __swSurface,
        double __pos[3],
        double __facePos[3],               // Array of 3 doubles
        double __uvParams[2]              // Array of 2 doubles
        );
            
template < class T >
void SW_Select_and_Mark(CComPtr< T > __swT, bool __append, long __mark)
{
        VARIANT_BOOL retval;
                CComQIPtr <Sldworks_tlb::IEntity> swQIEnt ( __swT );
 
        VARIANT_BOOL Append = __append ? 1 : 0;
        swQIEnt->Select2(Append, __mark, &retval);
}
 
CAD4FE_COMMON_ITEM void SW_Face_Select_and_Mark(CComPtr<IFace2> __swFace, bool __append, long __mark);
CAD4FE_COMMON_ITEM void SW_Sketch_Select_and_Mark(CComPtr<ISketch> __sketch, bool __append, long __mark);
CAD4FE_COMMON_ITEM void SW_Sketch_GetModelCoordinateInSketchSpace(CComPtr<ISketch> __sketch, double __pos_3D[3], double __pos_sketch[3]);
CAD4FE_COMMON_ITEM void SW_Sketch_GetModelCoordinateInSketchSpace(CComPtr<ISketch> __sketch, double __pos_sketch[3], double __pos_3D[3]);
 
CAD4FE_COMMON_ITEM void SW_GetActiveView (CComPtr<IModelDoc2> __swModel, CComPtr<IModelView> & __swModelView);
CAD4FE_COMMON_ITEM bool  SW_Face_GetMaterialPropertyValues2(CComPtr<IFace2> __swFace, double *R, double *G,  double *B, double *ambient, double *diffuse, double *specular, double *shininess, double *transparency, double *emission);
CAD4FE_COMMON_ITEM bool  SW_SelectedEdgeProperties(CComPtr<IModelDoc2> __swModel, CComPtr<IEdge> __swEdge, std::string & __retName, bool & name_existed_before);
CAD4FE_COMMON_ITEM bool  SW_SelectedEdgeProperties(CComPtr<IModelDoc2> __swModel, CComPtr<IEdge> __swEdge, char * &,bool & name_existed_before);
CAD4FE_COMMON_ITEM bool  SW_SelectedFaceProperties(CComPtr<IModelDoc2> __swModel, CComPtr<IFace2> __swFace, char * & __retName, bool & name_existed_before);
CAD4FE_COMMON_ITEM bool  SW_SelectedFaceProperties(CComPtr<IModelDoc2> __swModel, CComPtr<IFace2> __swFace, std::string & __retName, bool & name_existed_before);
CAD4FE_COMMON_ITEM bool  SW_Face_NameById(CComPtr<IModelDoc2> __swModel, CComPtr<IFace2> __swFace, int & __id, bool & name_existed_before);
CAD4FE_COMMON_ITEM bool  SW_Edge_NameById(CComPtr<IModelDoc2> __swModel, CComPtr<IEdge> __swEdge, int & __id, bool & name_existed_before);
CAD4FE_COMMON_ITEM void SW_Model_GetActiveCameraPosition (CComPtr<IModelDoc2> __swModel, double __result[3]);
CAD4FE_COMMON_ITEM void SW_Model_AddConfiguration(CComPtr<IModelDoc2> & __swModel, std::string __strname, CComPtr<IConfiguration> & __result);
CAD4FE_COMMON_ITEM bool SW_Model_SuppressConfiguration(CComPtr<IModelDoc2> & __swModel, std::string __name);
CAD4FE_COMMON_ITEM bool SW_SelectedEdgeProperties(CComPtr<IModelDoc2> __swModel, CComPtr<IEdge> __swEdge, char * & __retName, bool & name_existed_before);
 
CAD4FE_COMMON_ITEM CComPtr<IPartDoc> & SW_Model_GetPart(CComPtr<IModelDoc2> __swModel);
CAD4FE_COMMON_ITEM void SW_Model_GetActiveViewTranslation(CComPtr<IModelDoc2> __swModel, double __result[3]);
CAD4FE_COMMON_ITEM void SW_Model_SetAddToDB(CComPtr<IModelDoc2> __swModel, bool __status);
CAD4FE_COMMON_ITEM void SW_Model_CreateLineInSketch (CComPtr<IModelDoc2> __swModel, CComPtr<ISketch> __swSketch, double __P0[3], double __P1[3]);
CAD4FE_COMMON_ITEM int SW_Sketch_Select(CComPtr<ISketch> __swSketch, CComPtr <ISelectData> __swSelData);
CAD4FE_COMMON_ITEM int SW_SketchSegment_Select(CComPtr<ISketchSegment> __swSketchSegment, CComPtr <ISelectData> __swSelData);
CAD4FE_COMMON_ITEM int SW_SketchPoint_Select(CComPtr<ISketchPoint> __swSketchPoint, CComPtr <ISelectData> __swSelData);
CAD4FE_COMMON_ITEM void SW_Model_InsertSplitLine ( CComPtr<IModelDoc2> __swModel, CComPtr<ISketch> __swSketch, CComPtr<IFace2> __swFace,
        std::map < int, CComPtr<IFace2> > & __resultFaces );
CAD4FE_COMMON_ITEM void SW_Model_InsertSplitLine(CComPtr<IModelDoc2> __swModel,
                                                CComPtr<IFace2> __swFace, double __vertex1coordinates[3], double __vertex2coordinates[3], 
                std::map < int, CComPtr<IFace2> > & __resultFaces);
CAD4FE_COMMON_ITEM void
SW_Model_CreateRefPlane(CComPtr<IModelDoc2> __swModel,  double __rootPoint[3], double __normal[3], CComPtr<IRefPlane> & __swRefPlane );
 template <class T>
CAD4FE_COMMON_ITEM CComPtr<T> & SW_Model_GetFirstSelected(CComPtr <IModelDoc2> __swModel, long __mark)
{
        CComPtr<T> * __swEnt = new CComPtr<T>;
        HRESULT hr;
        CComPtr <ISelectionMgr> swSelMgr;
 
        __swModel->get_ISelectionManager ( &swSelMgr );
 
        CComPtr <IDispatch>  pUnk1;
 
        long count=0;
        swSelMgr->GetSelectedObjectCount(&count);
 
        for (int i=1; i <= count ; i++)
        {
                pUnk1 = NULL;
                if ( S_OK != swSelMgr->GetSelectedObject6 (i, __mark, &pUnk1) )
                {                     
                        *__swEnt = 0;
                        return *__swEnt;
                }
                if (!pUnk1)
                {                     
                        *__swEnt = 0;
                        return *__swEnt;
                }
                CComQIPtr<T> qiSelectedEnt (pUnk1);
                CComPtr<T> selectedEnt (qiSelectedEnt);
 
                if (selectedEnt)
                {
                        *__swEnt = selectedEnt;
                        return *__swEnt;
                }
        }
        
        *__swEnt = 0;
 
        return *__swEnt;
}
 
 
 template <class T>
CAD4FE_COMMON_ITEM CComPtr<T> & SW_Model_GetSelected(CComPtr <IModelDoc2> __swModel, long __nth, long __mark)
{
        HRESULT hr;
        CComPtr <ISelectionMgr> swSelMgr;
        CComPtr<T> * __swEnt = new CComPtr<T>;
 
        __swModel->get_ISelectionManager ( &swSelMgr );
 
        CComPtr <IDispatch>  pUnk1;
 
        long count=0;
        swSelMgr->GetSelectedObjectCount(&count);
 
        long counter = 0;
 
        for (int i=1; i <= count ; i++)
        {
                pUnk1 = NULL;
                if ( S_OK != swSelMgr->GetSelectedObject6 (i, __mark, &pUnk1) )
                {
                        __swEnt = 0;
                        return *__swEnt;
                }
                if (!pUnk1)
                {
                        __swEnt = 0;
                        return *__swEnt;
                }
                CComQIPtr<T> qiSelectedEnt (pUnk1);
                CComPtr<T> selectedEnt (qiSelectedEnt);
 
                if (selectedEnt)
                {
                        if (counter+1 == __nth)
                        {
                                *__swEnt = selectedEnt;
                                return *__swEnt;
                        }
                        else
                        {
                                counter++;
                        }
                }
        }
        *__swEnt = 0;
 
        return *__swEnt;
}
 
CAD4FE_COMMON_ITEM int SW_GetSelecteEdgeId(CComPtr<ISldWorks> __swApp);
 
 
template <class T>
void SW_Feature_GetDefinition(CComPtr<IFeature> __swFeature, CComPtr<T> & __swFeatData)
{
        HRESULT hres;
        LPUNKNOWN iUnk = NULL;
 
        hres = __swFeature->IGetDefinition( &iUnk );
        hres = iUnk->QueryInterface( __uuidof(T), (LPVOID*)&__swFeatData);
}
 
CAD4FE_COMMON_ITEM void SW_Part_InitIDs(CComPtr<IPartDoc> __swPart);
 
CAD4FE_COMMON_ITEM int
SW_Part_GetBodiesCount(CComPtr<IPartDoc> __swPart, swBodyType_e __swBodyType, bool __onlyVisibleBodies=true);
 
CAD4FE_COMMON_ITEM CComPtr<IBody2> &
SW_Part_GetBody(CComPtr<IPartDoc> __swPart, int __index, swBodyType_e __swBodyType, bool __onlyVisibleBodies=true);
 
CAD4FE_COMMON_ITEM void
SW_Model_SaveToFile(CComPtr<IModelDoc2> __swModel, const char * __filename);
CAD4FE_COMMON_ITEM void SW_Part_FindEdgeById(CComPtr<IPartDoc> __swPart, int __id, CComPtr <IEdge> & __swEdge);
CAD4FE_COMMON_ITEM void SW_Part_FindFaceById(CComPtr<IPartDoc> __swPart, int __id, CComPtr <IFace2> & __swFace);
 
CAD4FE_COMMON_ITEM void   SW_Vertex_GetPoint(CComPtr<IVertex> __swVertex, double __pnt[3]);
CAD4FE_COMMON_ITEM int SW_Vertex_GetId(const CComPtr <IVertex> & __swVertex);
 
CAD4FE_COMMON_ITEM int SW_Vertex_TestAttribute(CComPtr<IVertex> & __swVertex,CComPtr <IAttributeDef> &);
CAD4FE_COMMON_ITEM bool SW_Face_IsCylinder(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM bool SW_Surface_IsCylinder(CComPtr<ISurface> __swSurface);
CAD4FE_COMMON_ITEM bool SW_Face_IsCone(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM bool SW_Surface_IsCone(CComPtr<ISurface> __swSurface);
CAD4FE_COMMON_ITEM bool SW_Face_IsPlane(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM bool SW_Surface_IsPlane(CComPtr<ISurface> __swSurface);
CAD4FE_COMMON_ITEM bool SW_Face_IsTorus(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM bool SW_Surface_IsTorus(CComPtr<ISurface> __swSurface);
CAD4FE_COMMON_ITEM bool SW_Face_IsSphere(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM bool SW_Surface_IsSphere(CComPtr<ISurface> __swSurface);
CAD4FE_COMMON_ITEM bool SW_Face_IsSwept(CComPtr<IFace2> __swFace);
CAD4FE_COMMON_ITEM bool SW_Surface_IsSwept(CComPtr<ISurface> __swSurface);
 
 
CAD4FE_COMMON_ITEM void
SW_RefPlane_GetParams (CComPtr<IRefPlane> __swRefPlane, double __origin[3], double __normal[3], double __XVector[3]);
 
 
#define FACENAME_FORMAT "F %d    "
#define FACENAME_STRLEN 64        
#define EDGENAME_FORMAT "E %d    "
#define EDGENAME_STRLEN 64
#define VERTEXNAME_FORMAT "Vertex %f, %f, %f    "
#define VERTEXNAME_STRLEN 64
int CAD4FE_COMMON_ITEM Convert_FaceNameToId(std::string);
int CAD4FE_COMMON_ITEM Convert_FaceNameToId(char *);
int CAD4FE_COMMON_ITEM Convert_FaceNameToId(BSTR);
 
bool CAD4FE_COMMON_ITEM SW_FaceName_Set(CComPtr<IPartDoc> __swPart, CComPtr<IFace2>, std::string &, bool overwrite_option=false);
bool CAD4FE_COMMON_ITEM SW_FaceName_Set(CComPtr<IPartDoc> __swPart, CComPtr<IFace2>, char *, bool overwrite_option=false);
 
bool CAD4FE_COMMON_ITEM SW_FaceName_Get(CComPtr<IPartDoc> __swPart, CComPtr<IFace2>, std::string &);
bool CAD4FE_COMMON_ITEM SW_FaceName_Get(CComPtr<IPartDoc> __swPart, CComPtr<IFace2>, char **);
 
                
CAD4FE_COMMON_ITEM int
SW_Model_RayIntr_GetFirstFaceIntr(CComPtr<IModelDoc2> __swModel, double __basePointIn[3],
double __baseDirectionIn[3],
CComPtr<IFace2> & __swFace, double __intrPoint[3], double __intrPointNorm[3]);
                                                                                                         
CAD4FE_COMMON_ITEM void SW_MathVector_ConvertToPoint(CComPtr<IMathVector>  __swMathVector,CComPtr<IMathPoint> &__swMathPoint);
 
 
CAD4FE_COMMON_ITEM void
SW_MathPoint_GetCoordinates(CComPtr<IMathPoint> __swMathPoint, double __pos[3]);
                                                                         
void
SW_RefPoint_GetPoint(CComPtr<IRefPoint> __swRefPoint, double __result[3]);
 
CAD4FE_COMMON_ITEM void SW_ModelView_GetTranslation(CComPtr<IModelView> __swModelView, double __result[3]);
 
 
int CAD4FE_COMMON_ITEM Convert_EdgeNameToId(std::string);
int CAD4FE_COMMON_ITEM Convert_EdgeNameToId(char *);
int CAD4FE_COMMON_ITEM Convert_EdgeNameToId(BSTR);
 
bool CAD4FE_COMMON_ITEM SW_EdgeName_Set(CComPtr<IPartDoc>, CComPtr<IEdge>, std::string &, bool overwrite_option=false);
bool CAD4FE_COMMON_ITEM SW_EdgeName_Set(CComPtr<IPartDoc>, CComPtr<IEdge>, char *, bool overwrite_option=false);
 
bool CAD4FE_COMMON_ITEM SW_EdgeName_Get(CComPtr<IPartDoc>, CComPtr<IEdge>, std::string &);
bool CAD4FE_COMMON_ITEM SW_EdgeName_Get(CComPtr<IPartDoc>, CComPtr<IEdge>, char **);
bool CAD4FE_COMMON_ITEM SW_EdgeName_Get(CComPtr<IPartDoc>, CComPtr<IEdge>, const char *);
 
bool CAD4FE_COMMON_ITEM SW_EdgeName_Delete(CComPtr<IPartDoc> __swPart, CComPtr<IEdge> __swEdge);
 
std::string CAD4FE_COMMON_ITEM Convert_VertexToString(CComPtr<IVertex> __swVertex);
bool CAD4FE_COMMON_ITEM SW_VertexName_Set(CComPtr<IPartDoc>, CComPtr<IVertex>, std::string &, bool overwrite_option=false);
bool CAD4FE_COMMON_ITEM SW_VertexName_Set(CComPtr<IPartDoc>, CComPtr<IVertex>, char *, bool overwrite_option=false);
 
bool CAD4FE_COMMON_ITEM SW_VertexName_Get(CComPtr<IPartDoc>, CComPtr<IVertex>, std::string &);
bool CAD4FE_COMMON_ITEM SW_VertexName_Get(CComPtr<IPartDoc>, CComPtr<IVertex>, char **);
 
bool CAD4FE_COMMON_ITEM SW_EntityName_Delete(CComPtr<IPartDoc>, CComPtr<Sldworks_tlb::IEntity>);
bool CAD4FE_COMMON_ITEM SW_EntityName_Set(CComPtr<IPartDoc>, CComPtr<Sldworks_tlb::IEntity> __swEntity, BSTR & __bstrName, bool overwrite=false);
bool CAD4FE_COMMON_ITEM SW_EntityName_Get(CComPtr<IPartDoc>, CComPtr<Sldworks_tlb::IEntity> __swEntity, BSTR & __bstrName);
 
 
#endif