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:	283
Committed:	Tue Sep 13 21:11:20 2011 UTC (13 years, 8 months ago) by francois
File size:	24426 byte(s)
Log Message:	structure de l'écriture