diamesh/src/p3d_envel.cpp


#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include "p3d_cst.h"
#include "m3d_struct.h"
#include "m3d_hotes.h"
#include "m3d_erreur.h"
#include "prototype.h"
extern GEST_MEM *gest ;
extern int debug ;
int p3d_envel(void)
{
    /* ************************************************* */
    /* declaration des variables internes a la procedure */
    ELEMENT *tete;/* tete des elements du front */
    SURFACE *surf, *surf_ext ;
    int i, num, gtrouve, k, ierr  ;
    int is_ok, nb_inter, nb, j, nb_reel, jmax ;
    float vec_posi[NB_MAX_INTER], vmax, *v_inter  ;
    int iordre[NB_MAX_INTER], is ;
    int ipair, nb_neg, k1, k2 ;

    /* debut du code executable */

    ierr = 0 ;
    gest->nb_surf = 0 ;
    /* determination du nombre de surfaces par un algorithme frontal */
    if (!p3d_nbsurf())
    {
        if (debug) printf("%s\n"," erreur p3d_nbsurf P3D_ENVEL ") ;
        return(FAUX) ;
    }

    /* creation et orientation des surfaces, creations des volumes enveloppes */
    gest->tab_surf = (SURFACE *)calloc(gest->nb_surf,sizeof(SURFACE)) ;
    ERREUR_ALLOC(gest->tab_surf)

    for (i=0;i<gest->nb_surf;i++)
    {
        (gest->tab_surf[i]).etat = UNKNOWN ;
        (gest->tab_surf[i]).ele = NULL ;
        (gest->tab_surf[i]).suivant = NULL ;
        (gest->tab_surf[i]).envel = NULL ;
    }

    /* affecter les elements aux surfaces */
    for (i=0;i<gest->nb_2d;i++)
    {
        /* pointeur element i */
        tete = &(gest->tab_ele[i]) ;
        /* surface d'appartenance */
        surf = &(gest->tab_surf[(tete->mark)-1]) ;/* pointeur sur la surface */
        INSERE_TETE(surf->ele,tete)
        /* insertion en tete de l'element tete dans la liste d'elements surface->ele */
    }

    for (i=0;i<gest->nb_2d;i++) (gest->tab_ele[i]).mark = 0 ;

    /* a ce stade. on a cree des surfaces reperees dans tab_surf et on leur a affecte des listes d'elements */
    /* orientation des surfaces */
    for (is=0;is<gest->nb_surf;is++)
    {
        surf = &(gest->tab_surf[is]) ;
        /* on choisit un element sur la surface */
        tete = surf->ele ;
        /* tete de liste des elements de la surface */
        /* orientation de la surface surf */
        while (tete!=NULL)
        {
            nb = 0 ;
            nb_reel = 0 ;
            nb_neg = 0 ;
            /* INTERSECTION entre la droite passant par le barycentre de l'element et
            de vecteur directeur la normale a l'element et la surface reperee par tab_surf[j] */
            /* en sortie nb, nombre de points d'intersection */
            /* strategie pour les points doubles : on les evite pour le moment en choisissant
            un autre element sur la surface */
            /* on pourra par la suite trier les points doubles, voir triples */
            p3d_inter(gest->vcorg,gest->tabele,surf,tete,&nb,&nb_reel,&nb_neg,vec_posi,&ierr) ;
            /* erreur */
            if (ierr==VRAI)
            {
                if (debug) printf("%s\n"," erreur p3d_inter P3D_ENVEL ") ;
                return(FAUX) ;
            }
            if (nb==UNKNOWN)
            {
                tete=tete->suivant ;
            }
            else
            {
                /* l'element n'a pas permis de conclure (is_ok==FAUX), il faut passer au suivant
                sinon on passe a la surface suivante */

                for (i=0;i<nb_reel;i++) iordre[i] = i+1 ;/* attention passage c fortran */
                trirea(vec_posi,&nb_reel,iordre) ;
                /* on oriente la surface */
                /* test sur la parite du nombre d'intersections */
                /* recherche dans vec_posi */
                i = 0 ;
                while (i<=nb_reel)
                {
                    i++ ;
                    if ((float)fabs((double)vec_posi[i-1])<EPSILON)
                    {
                        break ;
                    }
                }
                ipair = i - 2 *(int)(i/2) ;
                if (ipair==1) /* normale interieure */
                {
                    /* on change l'orientation d'un element en inversant une arete */
                    num = gest->tabele[3*(tete->num)] ;
                    /* premier noeud de l'element */
                    gest->tabele[3*(tete->num)]=gest->tabele[3*(tete->num)+1] ;
                    gest->tabele[3*(tete->num)+1] = num ;
                }
                /* ORIENTATION SUIVANT UN ALGORITHME FRONTAL */
                if (!p3d_orient(tete->num))
                {
                    if (debug) printf("%s\n"," erreur p3d_orient P3D_ENVEL ") ;
                    return(FAUX) ;
                }
                break ;
            }
        }
    }
    /* position relative des surfaces */
    /* pour chacune des surfaces, on doit determiner si la surface est exterieur, ou interieur */
    /* pour chacune des surfaces, on determine le nombre d'intersections dont l'abscisse curviligne est
    strictement negative :
    - avec toutes les autres surfaces --------> k1
    - avec la surface elle meme --------------> k2

    si k1 + k2 est pair, la surface est exterieure et on peut creer un volume sinon la surface est exterieure
    et on chaine celle ci avec la surface exterieure associee */
    /* parcours de tab_surf */

    gest->v_inter = (float*)calloc(gest->nb_surf * gest->nb_surf,sizeof(float)) ;
    ERREUR_ALLOC(gest->v_inter) ;
    if (gest->nb_surf>1)
    {
        for (i=0;i<gest->nb_surf;i++)
        {
            /* changer l'implementation voir ci dessus */
            k1 = 0 ;/* nombre d'intersections avec toutes les autres surfaces */
            k2 = 0 ;/* nombre d'intersections avec la surface elle meme */
            surf = &(gest->tab_surf[i]) ;
            /* on choisit un element sur la surface */
            tete = surf->ele ;/* tete de liste des elements de la surface */
            /* boucle sur les autres surfaces */
            for (j=0;j<gest->nb_surf;j++)
            {
                nb = 0 ;
                nb_reel = 0 ;
                nb_neg = 0 ;
                /* intersection surface i, surface j */
                p3d_inter(gest->vcorg,gest->tabele,&(gest->tab_surf[j]),tete,&nb,&nb_reel,&nb_neg,vec_posi,&ierr) ;
                if ((ierr==VRAI) || (nb==UNKNOWN))
                {
                    if (debug) printf("%s\n"," erreur p3d_inter P3D_ENVEL ") ;
                    return(FAUX) ;
                }
                /* tester la parite de nb_neg */
                ipair = nb_neg - 2 * (int)(nb_neg/2) ;
                if (ipair==0)
                {
                    /* nombre d'intersections paire */
                    gest->v_inter[gest->nb_surf*j+i] = 123456789. ;
                }
                else gest->v_inter[gest->nb_surf*j+i] = vec_posi[0] ;/* valeur mini car vec_posi est trie */
                if (i==j)
                {
                    k2 = nb_neg ;
                }
                k1 = k1 + nb_neg ;
            }
            ipair = (k1 + k2) - 2 *(int)((k1+k2)/2) ;
            if (ipair==0)
            {
                (gest->tab_surf[i]).etat= EXTERIEUR ;
            }
            else (gest->tab_surf[i]).etat = INTERIEUR ;
        }
    }
    else (gest->tab_surf[0]).etat = EXTERIEUR ;

    gest->envel = p3d_c_envel() ;/* creation du volume enveloppe */
    surf_ext = NULL ;
    if (gest->envel == NULL)
    {
        if (debug) printf("%s\n"," erreur P3D_ENVEL ") ;
        return(FAUX) ;
    }
    i = 0 ;
    while ((i<gest->nb_surf) /*&& (surf_ext == NULL)*/)
    {
        if ((gest->tab_surf[i]).etat == EXTERIEUR)
        {
            surf_ext = &(gest->tab_surf[i]) ;
            surf_ext->suivant=(gest->envel)->surf_ext;
            (gest->envel)->surf_ext = surf_ext ;/* on affecte la surface ext au volume */
            surf_ext->envel = gest->envel ;/* puis on affecte le volume a la surface ext */
        }
        i++ ;
    }
    if (surf_ext == NULL)
    {
        return(FAUX) ;
    }

    /* traitement des surfaces interieures */
    for (i=0;i<gest->nb_surf;i++)
    {
        if ((gest->tab_surf[i]).etat == INTERIEUR)
        {
            surf = &(gest->tab_surf[i]) ;/* surface interieure */
            /* insertion en tete de liste des surfaces interieures liees au volume enveloppe */
            surf->suivant = (gest->envel)->surf_int ;
            (gest->envel)->surf_int = surf ;
        }
    }

    free(gest->v_inter) ;
    gest->v_inter = NULL ;
    return(VRAI) ;
}

Revision:	283
Committed:	Tue Sep 13 21:11:20 2011 UTC (13 years, 8 months ago) by francois
File size:	8456 byte(s)
Log Message:	structure de l'écriture
#	User	Rev	Content
1	francois	283
2			#include <stdio.h>
3			#include <math.h>
4			#include <stdlib.h>
5			#include "p3d_cst.h"
6			#include "m3d_struct.h"
7			#include "m3d_hotes.h"
8			#include "m3d_erreur.h"
9			#include "prototype.h"
10			extern GEST_MEM *gest ;
11			extern int debug ;
12			int p3d_envel(void)
13			{
14			/* ************************************************* */
15			/* declaration des variables internes a la procedure */
16			ELEMENT tete;/ tete des elements du front */
17			SURFACE surf, surf_ext ;
18			int i, num, gtrouve, k, ierr ;
19			int is_ok, nb_inter, nb, j, nb_reel, jmax ;
20			float vec_posi[NB_MAX_INTER], vmax, *v_inter ;
21			int iordre[NB_MAX_INTER], is ;
22			int ipair, nb_neg, k1, k2 ;
23
24			/* debut du code executable */
25
26			ierr = 0 ;
27			gest->nb_surf = 0 ;
28			/* determination du nombre de surfaces par un algorithme frontal */
29			if (!p3d_nbsurf())
30			{
31			if (debug) printf("%s\n"," erreur p3d_nbsurf P3D_ENVEL ") ;
32			return(FAUX) ;
33			}
34
35			/* creation et orientation des surfaces, creations des volumes enveloppes */
36			gest->tab_surf = (SURFACE *)calloc(gest->nb_surf,sizeof(SURFACE)) ;
37			ERREUR_ALLOC(gest->tab_surf)
38
39			for (i=0;i<gest->nb_surf;i++)
40			{
41			(gest->tab_surf[i]).etat = UNKNOWN ;
42			(gest->tab_surf[i]).ele = NULL ;
43			(gest->tab_surf[i]).suivant = NULL ;
44			(gest->tab_surf[i]).envel = NULL ;
45			}
46
47			/* affecter les elements aux surfaces */
48			for (i=0;i<gest->nb_2d;i++)
49			{
50			/* pointeur element i */
51			tete = &(gest->tab_ele[i]) ;
52			/* surface d'appartenance */
53			surf = &(gest->tab_surf[(tete->mark)-1]) ;/* pointeur sur la surface */
54			INSERE_TETE(surf->ele,tete)
55			/* insertion en tete de l'element tete dans la liste d'elements surface->ele */
56			}
57
58			for (i=0;i<gest->nb_2d;i++) (gest->tab_ele[i]).mark = 0 ;
59
60			/* a ce stade. on a cree des surfaces reperees dans tab_surf et on leur a affecte des listes d'elements */
61			/* orientation des surfaces */
62			for (is=0;is<gest->nb_surf;is++)
63			{
64			surf = &(gest->tab_surf[is]) ;
65			/* on choisit un element sur la surface */
66			tete = surf->ele ;
67			/* tete de liste des elements de la surface */
68			/* orientation de la surface surf */
69			while (tete!=NULL)
70			{
71			nb = 0 ;
72			nb_reel = 0 ;
73			nb_neg = 0 ;
74			/* INTERSECTION entre la droite passant par le barycentre de l'element et
75			de vecteur directeur la normale a l'element et la surface reperee par tab_surf[j] */
76			/* en sortie nb, nombre de points d'intersection */
77			/* strategie pour les points doubles : on les evite pour le moment en choisissant
78			un autre element sur la surface */
79			/* on pourra par la suite trier les points doubles, voir triples */
80			p3d_inter(gest->vcorg,gest->tabele,surf,tete,&nb,&nb_reel,&nb_neg,vec_posi,&ierr) ;
81			/* erreur */
82			if (ierr==VRAI)
83			{
84			if (debug) printf("%s\n"," erreur p3d_inter P3D_ENVEL ") ;
85			return(FAUX) ;
86			}
87			if (nb==UNKNOWN)
88			{
89			tete=tete->suivant ;
90			}
91			else
92			{
93			/* l'element n'a pas permis de conclure (is_ok==FAUX), il faut passer au suivant
94			sinon on passe a la surface suivante */
95
96			for (i=0;i<nb_reel;i++) iordre[i] = i+1 ;/* attention passage c fortran */
97			trirea(vec_posi,&nb_reel,iordre) ;
98			/* on oriente la surface */
99			/* test sur la parite du nombre d'intersections */
100			/* recherche dans vec_posi */
101			i = 0 ;
102			while (i<=nb_reel)
103			{
104			i++ ;
105			if ((float)fabs((double)vec_posi[i-1])<EPSILON)
106			{
107			break ;
108			}
109			}
110			ipair = i - 2 *(int)(i/2) ;
111			if (ipair==1) /* normale interieure */
112			{
113			/* on change l'orientation d'un element en inversant une arete */
114			num = gest->tabele[3*(tete->num)] ;
115			/* premier noeud de l'element */
116			gest->tabele[3(tete->num)]=gest->tabele[3(tete->num)+1] ;
117			gest->tabele[3*(tete->num)+1] = num ;
118			}
119			/* ORIENTATION SUIVANT UN ALGORITHME FRONTAL */
120			if (!p3d_orient(tete->num))
121			{
122			if (debug) printf("%s\n"," erreur p3d_orient P3D_ENVEL ") ;
123			return(FAUX) ;
124			}
125			break ;
126			}
127			}
128			}
129			/* position relative des surfaces */
130			/* pour chacune des surfaces, on doit determiner si la surface est exterieur, ou interieur */
131			/* pour chacune des surfaces, on determine le nombre d'intersections dont l'abscisse curviligne est
132			strictement negative :
133			- avec toutes les autres surfaces --------> k1
134			- avec la surface elle meme --------------> k2
135
136			si k1 + k2 est pair, la surface est exterieure et on peut creer un volume sinon la surface est exterieure
137			et on chaine celle ci avec la surface exterieure associee */
138			/* parcours de tab_surf */
139
140			gest->v_inter = (float)calloc(gest->nb_surf gest->nb_surf,sizeof(float)) ;
141			ERREUR_ALLOC(gest->v_inter) ;
142			if (gest->nb_surf>1)
143			{
144			for (i=0;i<gest->nb_surf;i++)
145			{
146			/* changer l'implementation voir ci dessus */
147			k1 = 0 ;/* nombre d'intersections avec toutes les autres surfaces */
148			k2 = 0 ;/* nombre d'intersections avec la surface elle meme */
149			surf = &(gest->tab_surf[i]) ;
150			/* on choisit un element sur la surface */
151			tete = surf->ele ;/* tete de liste des elements de la surface */
152			/* boucle sur les autres surfaces */
153			for (j=0;j<gest->nb_surf;j++)
154			{
155			nb = 0 ;
156			nb_reel = 0 ;
157			nb_neg = 0 ;
158			/* intersection surface i, surface j */
159			p3d_inter(gest->vcorg,gest->tabele,&(gest->tab_surf[j]),tete,&nb,&nb_reel,&nb_neg,vec_posi,&ierr) ;
160			if ((ierr==VRAI) \|\| (nb==UNKNOWN))
161			{
162			if (debug) printf("%s\n"," erreur p3d_inter P3D_ENVEL ") ;
163			return(FAUX) ;
164			}
165			/* tester la parite de nb_neg */
166			ipair = nb_neg - 2 * (int)(nb_neg/2) ;
167			if (ipair==0)
168			{
169			/* nombre d'intersections paire */
170			gest->v_inter[gest->nb_surf*j+i] = 123456789. ;
171			}
172			else gest->v_inter[gest->nb_surfj+i] = vec_posi[0] ;/ valeur mini car vec_posi est trie */
173			if (i==j)
174			{
175			k2 = nb_neg ;
176			}
177			k1 = k1 + nb_neg ;
178			}
179			ipair = (k1 + k2) - 2 *(int)((k1+k2)/2) ;
180			if (ipair==0)
181			{
182			(gest->tab_surf[i]).etat= EXTERIEUR ;
183			}
184			else (gest->tab_surf[i]).etat = INTERIEUR ;
185			}
186			}
187			else (gest->tab_surf[0]).etat = EXTERIEUR ;
188
189			gest->envel = p3d_c_envel() ;/* creation du volume enveloppe */
190			surf_ext = NULL ;
191			if (gest->envel == NULL)
192			{
193			if (debug) printf("%s\n"," erreur P3D_ENVEL ") ;
194			return(FAUX) ;
195			}
196			i = 0 ;
197			while ((i<gest->nb_surf) /&& (surf_ext == NULL)/)
198			{
199			if ((gest->tab_surf[i]).etat == EXTERIEUR)
200			{
201			surf_ext = &(gest->tab_surf[i]) ;
202			surf_ext->suivant=(gest->envel)->surf_ext;
203			(gest->envel)->surf_ext = surf_ext ;/* on affecte la surface ext au volume */
204			surf_ext->envel = gest->envel ;/* puis on affecte le volume a la surface ext */
205			}
206			i++ ;
207			}
208			if (surf_ext == NULL)
209			{
210			return(FAUX) ;
211			}
212
213			/* traitement des surfaces interieures */
214			for (i=0;i<gest->nb_surf;i++)
215			{
216			if ((gest->tab_surf[i]).etat == INTERIEUR)
217			{
218			surf = &(gest->tab_surf[i]) ;/* surface interieure */
219			/* insertion en tete de liste des surfaces interieures liees au volume enveloppe */
220			surf->suivant = (gest->envel)->surf_int ;
221			(gest->envel)->surf_int = surf ;
222			}
223			}
224
225			free(gest->v_inter) ;
226			gest->v_inter = NULL ;
227			return(VRAI) ;
228			}
229