geometrie/src/sld_fonction.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuillière et Vincent FRANCOIS
//  Département de Génie Mécanique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du département
//  de génie mécanique de l'Université du Québec à
//  Trois Rivières
//  Les librairies ne peuvent être utilisées sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       sld_fonction.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 à 11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#ifdef BREP_SLD
//#include <atl\atlmod.h>
#include "smartvars.h"
//#include <clx.h>
//#include "sldworks_tlb.h"
//#include "swconst_tlb.h"

#include <iostream>

#include <system.hpp>
#include "sld_fonction.h"
#include <math.h>
#include <string.h>
#include <iostream>
#include <stdlib.h>


using namespace std;

SLD_FONCTION::SLD_FONCTION():ouvert(0)
{
tolerance = 0;
}

SLD_FONCTION::~SLD_FONCTION()
{
    if (swApp.p!=NULL) swApp.p = NULL;
    if (swModel.p != NULL) swModel.p = NULL;
}


void SLD_FONCTION::OuvrirFichier(char* file)
{
    WideString acstostr(file);
    BSTR filename=BSTR(acstostr);
    WideString acstostr2("");
    BSTR configuration=BSTR(acstostr2);

        long type ;
        type=1 ;
        long options ;
        options= 1;

        long Errors;
        long Warnings;
        swApp->OpenDoc6(filename, type, options, configuration, &Errors, &Warnings, &swModel);
    //swApp->Visible;
        double tolerance=1E-5;
        Modeler_SetToleranceValue(1,tolerance); 
        Modeler_SetToleranceValue(2,tolerance);
    
    return ;

}


void SLD_FONCTION::get_face_tessellation(CComPtr<IFace2> __swFace, long *__triangleCount, double ** __tessPts)
{
    HRESULT hr;
    hr = __swFace->GetTessTriangleCount(__triangleCount);
    if (hr != S_OK)return;

    CComVariant vTessTriang;
    hr = __swFace->GetTessTriangles(VARIANT_TRUE, &vTessTriang);  
    if (hr != S_OK)return;
    SafeFloatArray saTessPts (vTessTriang);

    unsigned long nbCoords = *__triangleCount*9;
        *__tessPts = new double [nbCoords];

        for (unsigned i=0; i < nbCoords; i++)
        {
                (*__tessPts)[i] = saTessPts[i];
        }
}

/*
iTol=1 : swBSCurveOutputTol -3 D bspline curve output tolerance (meters)
iTol=2 : swBSCurveNonRationalOutputTol - 3D nonrational b-spline curve output tolerance (meters)
iTol=3 : swUVCurveOutputTol - 2D trim curve output tolerance (fraction of characteristic minimum face dimension)
iTol=4 : swSurfChordTessellationTol - Chord tolerance or deviation for tessellation for surfaces
iTol=5 : swSurfAngularTessellationTol - Angular tolerance or deviation for tessellation for surfaces
iTol=6 : swCurveChordTessellationTol - Chord tolerance or deviation for tessellation for curves
*/
void SLD_FONCTION::Modeler_SetToleranceValue(long iTol, double __tolerance)
{
    long iswToleranceID;
    switch (iTol)
    {
        case 1: iswToleranceID = swBSCurveOutputTol;
        break;
        case 2: iswToleranceID = swBSCurveNonRationalOutputTol;
        break;
        case 3: iswToleranceID = swUVCurveOutputTol;
        break;
        case 4: iswToleranceID = swSurfChordTessellationTol;
        break;
        case 5: iswToleranceID = swSurfAngularTessellationTol;
        break;                                         
        case 6: iswToleranceID = swCurveChordTessellationTol;
        break;
        default:
        return;
    }
    CComPtr<IModeler> swModeler;
    swApp->IGetModeler(&swModeler);
    /*double oldTol=*/swModeler->SetToleranceValue(iswToleranceID,__tolerance);
}


void SLD_FONCTION::Sauvegarder(char* file)
{
short retval =-1;
long Errors = -1;
long Warnings=-1;

WideString acstostr(file);
BSTR nom=BSTR(acstostr);
swModel->SaveAs4 ( nom, swSaveAsCurrentVersion, swSaveAsOptions_SaveReferenced , &Errors, &Warnings ,&retval);
//if (retval==0 || hres !=S_OK)
        //cout<<"Sauvegarde échouée!"<<endl;
return;
}


void SLD_FONCTION::Connection(void)
{
//HRESULT hres;
CoInitialize(NULL);               //Initialize COM
swApp.CoCreateInstance(CLSID_SldWorks_, NULL,   CLSCTX_LOCAL_SERVER);   //Create an instance of SolidWorks
//HRESULT status =swApp->put_Visible( true );
ouvert=1;
return;
}


void SLD_FONCTION::Fermer(void)
{
if (!ouvert) return;
swApp->ExitApp();
swApp = NULL;
CoUninitialize();
return;
}


// ********************************************************************
// ******** Procédure qui met un nom sur les entités de solidworks ****
// ********************************************************************

void SLD_FONCTION::identificateur(void)
{
    VideNom();    // procédure qui s'assure que toutes les entités sont vides (n'ont pas de nom)
    CComQIPtr <IPartDoc> swPart;
    swPart = swModel;
        CComVariant vBodyArr;  // si plus d'un corps dans le fichier part
        swPart->GetBodies2(swSolidBody, VARIANT_TRUE, &vBodyArr);
        SAFEARRAY*              psaBody = V_ARRAY(&vBodyArr);
    LPDISPATCH*             pBodyDispArray = NULL;
    long                    nBodyHighIndex = -1;
    long                    nBodyCount = -1;
    SafeArrayAccessData(psaBody, (void **) &pBodyDispArray);
    SafeArrayGetUBound(psaBody, 1, &nBodyHighIndex);
    nBodyCount = nBodyHighIndex + 1;
    for (int i = 0; i < nBodyCount; i++)
         {
                CComQIPtr <IBody2>          pBody;
                pBody = pBodyDispArray[i];
                CComPtr <IFace2> face;
                CComPtr <IFace2> suivantface;
                CComPtr <ISurface> surf;
                long nbFaces;
                pBody->GetFaceCount(&nbFaces);
                pBody->IGetFirstFace(&face);

                for(int f=0;f<nbFaces;f++)// boucle sur les faces
                {
                    SetID(face.p,0);
                        CComPtr <ILoop2> loope;
                        CComPtr <ILoop2> nextloope;
                        face->IGetFirstLoop(&loope);
                        long nbloop = -1;
                        face->GetLoopCount(&nbloop);
                        for (int l = 0;l<nbloop;l++)
                        {
                        // maintenant les aretes
                                CComPtr <ICoEdge> Coarete;
                                CComPtr <ICoEdge> nextCoarete;
                                loope->IGetFirstCoEdge(&Coarete);
                                long nbCoarete = -1;
                                loope->GetEdgeCount(&nbCoarete);
                                for (int coa=0;coa<nbCoarete;coa++)
                                {
                                        CComPtr <IEdge> arete;
                                        Coarete->IGetEdge(&arete);
                                        SetID(arete.p,0); // numérotation de l'arrète.
                                        CComPtr <IVertex> Sommet1;
                                        arete->IGetStartVertex(&Sommet1);

                                        if (Sommet1!=NULL)
                                        {
                                        SetID(Sommet1.p,0);
                                        CComPtr <IVertex> Sommet2;
                                        arete->IGetEndVertex(&Sommet2);
                                        SetID(Sommet2.p,0);
                                        Sommet2.Release();
                                        }
                                        arete.Release();
                                        Sommet1.Release();
                                        Coarete->IGetNext(&nextCoarete);
                                        Coarete = nextCoarete;
                                        nextCoarete.Release();
                                } // next CoEdge
                                Coarete.Release();
                                loope->IGetNext(&nextloope);
                                loope = nextloope;
                                nextloope.Release();

                        } // next loop
                        loope.Release();
                        face->IGetNextFace(&suivantface);
                        face = suivantface;
                        suivantface.Release();
                } // next face
                face.Release();
        pBody.Release();
        } // next body
return;
}             


//******************************************************************
void SLD_FONCTION::VideNom(void)
{
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
long count;
CComPtr <IEntity> entite;

swPart->GetNamedEntitiesCount ( &count );
if (count==0)
        return;

    CComVariant vBodyArr;  // si plus d'un corps dans le fichier part
        swPart->GetBodies2(swSolidBody, VARIANT_TRUE, &vBodyArr);
        SAFEARRAY*              psaBody = V_ARRAY(&vBodyArr);
    LPDISPATCH*             pBodyDispArray = NULL;
    long                    nBodyHighIndex = -1;
    long                    nBodyCount = -1;
    SafeArrayAccessData(psaBody, (void **) &pBodyDispArray);
    SafeArrayGetUBound(psaBody, 1, &nBodyHighIndex);
    nBodyCount = nBodyHighIndex + 1;

    for (int i = 0; i < nBodyCount; i++)
        {
        CComQIPtr <IBody2> pBody;
        pBody = pBodyDispArray[i];
                CComPtr <IFace2> face;
                CComPtr <IFace2> suivantface;
                CComPtr <ISurface> surf;
                long nbFaces;
                pBody->GetFaceCount(&nbFaces);
                pBody->IGetFirstFace(&face);

                for(int f=0;f<nbFaces;f++)// boucle sur les faces
                {
                    EffaceID(face);

                        CComPtr <ILoop2> loope;
                        CComPtr <ILoop2> nextloope;
                        face->IGetFirstLoop(&loope);
                        long nbloop = -1;
                        face->GetLoopCount(&nbloop);
                        for (int l = 0;l<nbloop;l++)
                        {
                                // maintenant les aretes
                                CComPtr <ICoEdge> Coarete;
                                CComPtr <ICoEdge> nextCoarete;
                                loope->IGetFirstCoEdge(&Coarete);
                                long nbCoarete = -1;
                                loope->GetEdgeCount(&nbCoarete);
                                for (int coa=0;coa<nbCoarete;coa++)
                                {

                                        CComPtr <IEdge> arete;
                                        Coarete->IGetEdge(&arete);

                                        EffaceID(arete.p);

                                        CComPtr <IVertex> Sommet1;
                                        arete->IGetStartVertex(&Sommet1);

                                        if (Sommet1!=NULL)
                                            {
                                            EffaceID(Sommet1.p);
                                            CComPtr <IVertex> Sommet2;
                                            arete->IGetEndVertex(&Sommet2);
                                            EffaceID(Sommet2.p);
                                            Sommet2.Release();
                                            }

                                        arete.Release();
                                        Sommet1.Release();

                                        Coarete->IGetNext(&nextCoarete);
                                        Coarete = nextCoarete;
                                        nextCoarete.Release();

                                } // next CoEdge
                                Coarete.Release();

                                loope->IGetNext(&nextloope);
                                loope = nextloope;
                                nextloope.Release();
                        } // next loop

                        loope.Release();
                        face->IGetNextFace(&suivantface);
                        face = suivantface;
                        suivantface.Release();
                } // next face
                face.Release();
                pBody.Release();
        } // next body

return;
}


//*****************************************
BOOL SLD_FONCTION::GetParID(char* ID, CComPtr<IFace2>  &face )
{
CComPtr <IEntity> ent;
WideString acstostr(ID);
BSTR nom=BSTR(acstostr);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->IGetEntityByName ( nom, swSelFACES , &ent ) ;     
if (ent == 0)
{
    face = 0;
    return false;
}
ent->QueryInterface( IID_IFace2, (LPVOID*)&face);

return true;
}

BOOL SLD_FONCTION::GetParID(BSTR nom, CComPtr<IFace2>  &face )
{
CComPtr <IEntity> ent;
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->IGetEntityByName ( nom, swSelFACES , &ent ) ;
if (ent == 0)
{
    face = 0;
    return false;
}
ent->QueryInterface( IID_IFace2, (LPVOID*)&face);

return true;
}

//*****************************************
BOOL SLD_FONCTION::GetParID(char* ID,CComPtr<IEdge> &arete)
{
CComPtr <IEntity> ent;
WideString acstostr(ID);
BSTR nom=BSTR(acstostr);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->IGetEntityByName ( nom, swSelEDGES , &ent ) ;
if (ent == 0)
{
   // on a peut-être un refEdge, c'est fucké, mais la solution suivante semble fonctioner..
    //*************************

    /* HRESULT                         hr = S_OK;
     long                            nEntCount = -1;
     CComPtr <IEntity>               pEntity;
     CComBSTR                        sEntName;

     hr = swPart->GetNamedEntitiesCount (&nEntCount);

     IEntity **ppEntity;
     ppEntity  = new  IEntity* [nEntCount];

     hr = swPart->IGetNamedEntities(nEntCount, ppEntity);

     for (long i = 0; i < nEntCount; i++)
         {
         pEntity= ppEntity[5];
         hr = swPart->IGetEntityName(pEntity, &sEntName);
         if (nom == sEntName )
            {
            pEntity->QueryInterface( IID_IEdge, (LPVOID*)&arete);
            return  true;
            }

         //pEntity = NULL;
         pEntity.Release();

         }
     delete sEntName;
     delete pEntity;

     delete [] ppEntity;
                       */
    //***************************
        // Ça marche pas, donc la prochaine solution est de parcourir les features, et de noter le nom de chaque edge puis voir si on a le bon...

CComPtr <IFeature> swFeat;
CComPtr <IFeature> swNextFeat;
VARIANT_BOOL bSupprime;
CComVariant vArete;
CComVariant vEdge;
CComPtr <IEntity> ent;

swPart->IFirstFeature(&swFeat);
while (swFeat)
    {
    swFeat->IsSuppressed(&bSupprime);
    if(!bSupprime)
        {
        CComBSTR NomFeat;
        swFeat->GetTypeName(&NomFeat);

        CComBSTR Compo1 ("CompositeCurve.");  // le dernier point est mangé par le BSTR
        CComBSTR Compo2 ("3DSplineCurve.");

        if ((Compo1==NomFeat) || (Compo2==NomFeat))      // code de traitement des poutres
            {
            CComPtr <IReferenceCurve>  refCourbe;
            CComPtr <IUnknown> Unk;

            swFeat->IGetSpecificFeature(&Unk);
            Unk->QueryInterface( IID_IReferenceCurve, (LPVOID*)&refCourbe);

            CComPtr<IEdge> swArete;
            refCourbe->IGetFirstSegment(&swArete);

            while(swArete)
                {
                char id3[1000];   // était dans la boucle while avant
                sprintf(id3,"%s",GetID(swArete.p).c_str());
                if (strcmp(ID, id3)==0  )
                    {
                    arete = swArete;
                    return  true;
                    }
                swArete.Release();
                refCourbe->IGetNextSegment(&swArete);
                }  // end while (swarete)
            } // end if feature est une poutre
        } // end if supprimé

        swFeat->IGetNextFeature(&swNextFeat);
        swFeat = swNextFeat;
        swNextFeat.Release();
    } // end while des features
           
    if (ent ==0)
    {
        arete = 0;
        return false;
    }
    return true;
}
ent->QueryInterface( IID_IEdge, (LPVOID*)&arete);
return true;
}


BOOL SLD_FONCTION::GetParID(BSTR nom,CComPtr<IEdge> &arete)
{
CComPtr <IEntity> ent;
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->IGetEntityByName ( nom, swSelEDGES , &ent ) ;
if (ent == 0)
{
    arete = 0;
    return false;
}
ent->QueryInterface( IID_IEdge, (LPVOID*)&arete);
return true;
}

//*****************************************
BOOL SLD_FONCTION::GetParID(char* ID,CComPtr<IVertex> &sommet)
{
CComPtr <IEntity> ent;
WideString acstostr(ID);
BSTR nom=BSTR(acstostr);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->IGetEntityByName ( nom, swSelVERTICES , &ent ) ;
if (ent == 0)
{
    printf("Failed to get %s\n", ID);
    sommet = 0;
    return false;
}
ent->QueryInterface( IID_IVertex, (LPVOID*)&sommet);
return true;
}

BOOL SLD_FONCTION::GetParID(BSTR nom,CComPtr<IVertex> &sommet)
{
CComPtr <IEntity> ent;
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->IGetEntityByName ( nom, swSelVERTICES , &ent ) ;     
if (ent == 0)
{
    sommet = 0;
    return false;
}
ent->QueryInterface( IID_IVertex, (LPVOID*)&sommet);
return true;
}

//********************************************************
BOOL SLD_FONCTION::GetParID(char* ID, CComPtr<ISurface> &surface)
{
        CComPtr<IFace2> face;
        GetParID( ID,face);  // on va chercher le pointeur pour la face
    face->IGetSurface(&surface);
return true;
}

//********************************************************
BOOL SLD_FONCTION::GetParID(char* ID,CComPtr<ICurve> &courbe)
{
    CComPtr<IEdge> arete;
        GetParID(ID,arete );
        arete->IGetCurve(&courbe);
return true;
}


//********************************************************
// ****  place l'ID de la Face dans solidworks  ****
// *******************************************************
void SLD_FONCTION::SetID(IFace2 *face, long type )
{

static long compteur=1;
CComPtr <IEntity> ent;
short retval;  //et la doc qui dit que ce doit être un booléen  ?!?

char nom2[20];

if( type==0 )// face normale apartient à un volume
        strcpy(nom2,"Face");
else  // face appartenant à une coque
        strcpy(nom2,"Face_Libre");

char nom3[10];
_ltoa(compteur,nom3,10);
strcat(nom2,nom3);

WideString acstostr(nom2);
BSTR nom=BSTR(acstostr);

face->QueryInterface( IID_IEntity, (LPVOID*)&ent);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->ISetEntityName( ent, nom , &retval );
if (retval!=0) compteur++;

}


void SLD_FONCTION::EffaceID(IFace2 *face)
{
CComPtr <IEntity> ent;
short retval;
face->QueryInterface( IID_IEntity, (LPVOID*)&ent);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->DeleteEntityName ( ent, &retval );

}


//********************************************************
void SLD_FONCTION::SetID(IEdge *arete,long type )
{

static long compteur=1;
CComPtr <IEntity> ent;
short retval;  //et la doc qui dit que ce doit être un booléen  ?!?

char nom2[20];

if( type==0 ) // arete apartient à un volume
        strcpy(nom2,"Arete");
else if (type==1)  // arete appartenant à une coque
        strcpy(nom2,"Arete_Coque");
else    // arete seule (poutre)
        strcpy(nom2,"Arete_Poutre");

char nom3[10];
_ltoa(compteur,nom3,10);
strcat(nom2,nom3);

WideString acstostr(nom2);
BSTR nom=BSTR(acstostr);

arete->QueryInterface( IID_IEntity, (LPVOID*)&ent);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->ISetEntityName( ent, nom , &retval );

if (retval!=0) compteur++;

}


void SLD_FONCTION::EffaceID(IEdge* arete)
{
CComPtr <IEntity> ent;
short retval;
arete->QueryInterface( IID_IEntity, (LPVOID*)&ent);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->DeleteEntityName ( ent, &retval );

}


//********************************************************
void SLD_FONCTION::SetID(IVertex* sommet,long type )
{

static long compteur=1;
CComPtr <IEntity> ent;
short retval;  //et la doc qui dit que ce doit être un booléen  ?!?

char nom2[20];

if( type==0 ) // sommet d'un volume
        strcpy(nom2,"Sommet");
else if (type==1)  // sommet d'une coque
        strcpy(nom2,"Sommet_Coque");
else    // sommet d'une poutre
        strcpy(nom2,"Sommet_Poutre");

char nom3[10];
_ltoa(compteur,nom3,10);
strcat(nom2,nom3);

WideString acstostr(nom2);
BSTR nom=BSTR(acstostr);

sommet->QueryInterface( IID_IEntity, (LPVOID*)&ent);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->ISetEntityName( ent, nom , &retval );

if (retval!=0) compteur++;

}

void SLD_FONCTION::EffaceID(IVertex* sommet)
{
CComPtr <IEntity> ent;
short retval;
sommet->QueryInterface( IID_IEntity, (LPVOID*)&ent);
CComQIPtr <IPartDoc> swPart;
swPart = swModel;
swPart->DeleteEntityName ( ent, &retval );

}


//*********************************************************
// **** Procédure qui renvoie le ID d'une arete **********
//*********************************************************
AnsiString SLD_FONCTION::GetID(IEdge* arete)
{

CComPtr <IEntity> ent;
CComPtr <IEdge> swarete(arete);
swarete->QueryInterface( IID_IEntity, (LPVOID*)&ent);

BSTR retval;
swModel->IGetEntityName ( ent, &retval );
sensMaitre = 1; // par défaut le sens est le même

// on vérifie, si c'est un esclave on retourne le nom du maitre.
CComPtr <IAttribute>  Attribut;
ent->IFindAttribute ( DefAttrDoublon, 0, &Attribut ) ;
if(Attribut!=NULL)
    {
    IParameter* parammaitre;
    CComBSTR nomParam("Maitre.") ;
    Attribut->IGetParameter ( nomParam, &parammaitre );
    parammaitre->GetStringValue(&retval) ;

    double sens2;
    IParameter* paramsens;
    CComBSTR nomParam2("Sens.") ;
    Attribut->IGetParameter ( nomParam2, &paramsens );
    paramsens->GetDoubleValue(&sens2) ;
    sensMaitre = sens2;
    }
else
    {
    swModel->IGetEntityName ( ent, &retval );
    }

AnsiString rep(retval);
return (rep);

}

//******************************************************
AnsiString SLD_FONCTION::GetID(IFace2* face)
{

CComPtr <IEntity> ent;
CComPtr <IFace2> swface(face);

swface->QueryInterface( IID_IEntity, (LPVOID*)&ent);

BSTR retval;
swModel->IGetEntityName ( ent, &retval );

AnsiString rep(retval);
return (rep);

}


//****************************
AnsiString SLD_FONCTION::GetID(IVertex* sommet )
{
CComPtr <IEntity> ent;
CComPtr<IVertex> swSommet(sommet);
swSommet->QueryInterface( IID_IEntity, (LPVOID*)&ent);
BSTR retval;


swModel->IGetEntityName ( ent, &retval );
// on vérifie, si c'est un esclave on retourne le nom du maitre.

CComPtr <IAttribute>  Attribut;
ent->IFindAttribute ( DefAttrDoublon, 0, &Attribut ) ;
if(Attribut!=NULL)
    {
    IParameter* parammaitre;
    CComBSTR nomParam("Maitre.") ;
    Attribut->IGetParameter ( nomParam, &parammaitre );
    parammaitre->GetStringValue(&retval) ;
    }
else
    {
    swModel->IGetEntityName ( ent, &retval );
    }

AnsiString rep(retval);
return (rep);

}


double SLD_FONCTION::GetValeurTolerance()
{
if(tolerance!=0) return tolerance;   // pour ne pas refaire le calcul plusieurs fois pour avoir la même valeur.
double petit = 999999999;
double actuelle = 0;

// on demande le body au model
CComVariant vBodyArr;  // si plus d'un corps dans le fichier part
CComQIPtr<IPartDoc> swPart;
swPart = swModel;
swPart->GetBodies2(swSolidBody, VARIANT_TRUE, &vBodyArr);
SAFEARRAY*              psaBody = V_ARRAY(&vBodyArr);
LPDISPATCH*             pBodyDispArray = NULL;
long                    nBodyHighIndex = -1;
SafeArrayAccessData(psaBody, (void **) &pBodyDispArray);
SafeArrayGetUBound(psaBody, 1, &nBodyHighIndex);
long nb_sld_corps = nBodyHighIndex + 1;

for (long i=0;i<nb_sld_corps;i++)   // boucle sur les corps
{
    CComQIPtr <IBody2> swBody;
    swBody = pBodyDispArray[i];
    double coins[6];
    CComVariant vRetval;
    vRetval=swBody->GetBodyBox();
    SafeDoubleArray sda(vRetval);
    //HRESULT status = swBody->IGetBodyBox ( coins );
    coins[0]=sda[0];
    coins[1]=sda[1];
    coins[2]=sda[2];
    coins[3]=sda[3];
    coins[4]=sda[4];
    coins[5]=sda[5];
    actuelle = sqrt( (coins[0] - coins[3])*(coins[0] - coins[3]) + (coins[1] - coins[4])*(coins[1] - coins[4]) + (coins[2] - coins[5])*(coins[2] - coins[5])) /10000000 ;
    //Gilles : avec une tolerance de 1E-8, SolidWorks plante lors de la fonction GetBCurbveParams
    actuelle = std::max(actuelle, 1E-6);
    if (actuelle <petit ) petit = actuelle;
}
tolerance = petit;

return tolerance;
}


#endif


Revision:	131
Committed:	Wed Jul 30 21:32:52 2008 UTC (16 years, 9 months ago) by bournival
Original Path:	*magic/lib/geometrie/geometrie/src/sld_fonction.cpp*
File size:	22548 byte(s)
Log Message:	Des modifications au sld_import et fem_maillage pour les Ã©tudes multidimensionnelles. Le code ne devrait pas affecter les autres Ã©tudes.