Manipulation de matrices

Version imprimable

31/07/2007, 13h37
bernard6

Manipulation de matrices
Bonjour,

Devant mettre à jour une structure, j'aimerai bien obtenir un vecteur colonne qui reprend dans un certain ordre (déterminé par les lignes de SegmentsCommuns) l'ensemble des points qui forment une frontière entre deux plans. A partir du vecteur PointsExtremes je connais le point origine et le point extrémité.

Voici un exemple pour bien comprendre :
Code:

1 2 3 4 5 PointsExtremes = [3; 4] SegmentsCommuns = [3 17; 15 11; 11 17 ; 12 15; 12 4] ResultatSouhaite = [3; 17; 11; 15; 12; 4]
Avez-vous une solution à ce problème ? Ce serait vraiment super !!!

Bon appétit et merci d'avance pour votre aide !
31/07/2007, 15h09
berberat

Bonjour,

je veux bien essayer de te repondre, mais tu veux bien t'y prendre autrement parce que j'ai pas bien saisi ce que tu veux dire.
:arf:

A+
31/07/2007, 15h15
bernard6

En fait la 1ere valeur de PointsExtremes correspond à la première valeur du vecteur de sortie (de même pour la dernière valeur).

Je connais donc les extrémités de la séquence souhaitée.

Ensuite pour avoir l'intérieur de la séquence, je dois regarder dans la matrice SegmentsCommuns où à partir de mon premier point (ici 3) je regarde l'autre élément de la ligne que je considère comme suivant dans mon vecteur de sortie jusqu'à ce que j'atteigne la derniere valeur (4)

J'espère que ça vous aide un petit peu :?

;)

Est ce que ce code répond à ta question ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
clear all
close all
 
PointsExtremes = [3; 4];
SegmentsCommuns = [3 17; 15 11; 11 17 ; 12 15; 12 4];
 
 
init=PointsExtremes(1);
fin=PointsExtremes(2);
 
i=1;
resultat(1)=init;
[prev_a prev_b]=find((SegmentsCommuns-init)==0);
if mod(prev_b,2)==0
    prev_b=prev_b-1;
else
    prev_b=prev_b+1;
end
init=SegmentsCommuns(prev_a(1),prev_b(1));
i=i+1;
resultat(i)=init;
while (not(resultat(end)==fin))
    i=i+1;
    [new_a new_b]=find((SegmentsCommuns-init)==0);
    if size(new_a==2)
        if ((new_a(1)-prev_a)==0)        
            prev_a=new_a(2);
            if mod(new_b(2),2)==0
                prev_b=new_b(2)-1;
            else
                prev_b=new_b(2)+1;
            end
            init=SegmentsCommuns(prev_a(1),prev_b(1));
        else    
             prev_a=new_a(1);
            if mod(new_b(1),2)==0
                prev_b=new_b(1)-1;
            else
                prev_b=new_b(1)+1;
            end
            init=SegmentsCommuns(prev_a(1),prev_b(1)) ;               
        end        
    end
    resultat(i)=init;
end 
 
ResultatSouhaite=resultat

31/07/2007, 16h55
bernard6

Le résultat est correct ! :king:

Je vais essayer d'explorer d'autres possibilités afin d'optimiser le tout mais en tout cas un grand merci ! :P
31/07/2007, 19h44
Jerome Briot

Quelle est le problème avec la solution que je t'ai donnée il y a quelques jours ?

Voir : mise a jour table polyligne frontière
31/07/2007, 22h59
bernard6

En fait votre solution m'a permis de réaliser une croissance correcte du plan à partir de la forme indiquée du polyligne frontière (je teste les points directement voisins).

Cette partie-ci vient en aval. Une fois les itérations finies, j'ai à ma disposition tous les points frontières. Ceux-ci sont projetés sur un plan qui approxime un certain nombre de points. Cependant au niveau des polylignes frontieres, il y a deux projections (vu que les points frontieres délimitent deux plans). Donc un point frontiere a deux projections. J'ai donc décidé de prendre en compte la droite d'intersection des deux plans et d'interpoler la position des points selon l'ordre dans lequel ils apparaissent selon la triangulation de Delaunay (d'où ce post-ci). Cette opération est nécessaire étant donné la structure du fichier vrml.

Je ne sais pas si c'est très clair pour vous. :? Si vous avez d'autres questions sur ce que j'ai fait, n'hésitez pas. En tout cas, je vous remercie pour l'aide que vous m'apportez !

Bonne soirée !

1 pièce(s) jointe(s)

Bonjour,

Ayant plus ou moins terminé ce programme, je viens de me rendre compte que je n'ai pas pris en compte un cas de figure en considération, ce qui est très problématique pour le fonctionnement du programme.

Je m'explique : en fait , j'ai considéré qu'entre 2 plans délimités par des segments frontières, il n'y avait que 2 points extrêmes :? Cependant, étant donné le cas de figure en annexe (segmentscommuns.jpg), je me rends compte qu'il peut y en avoir une infinité.

Le code que j'ai utilisé est le suivant (se référer au dessin pour bien visualiser) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 SegmentsCommuns = [16 10; 6 14; 12 2; 1 11; 14 5; 11 12; 9 16] % **** Mise en vecteur colonne des Segments communs SegmentsCommuns2 = [SegmentsCommuns(:,1);SegmentsCommuns(:,2)]; % **** Récupération des indices [iictttii,iiuii,iivii]=unique(SegmentsCommuns2,'rows'); % **** Histogramme du nombre de fois où chaque point apparait % dans SegmentsCommuns Histo = histc(iivii,[1:max(iivii)]); % **** Liste des Points extrêmes PE=find(Histo==1); PointsExtremes = iictttii([PE])
Je retrouve bien mes points extrêmes : [1;2;6;9;10]

Cependant, afin que la suite du programme fonctionne correctement, j'aurais aimé séparer la matrice SegmentsCommuns par segments qui se suivent afin de retrouver les points extrêmes pour chacun de ces segments.

Donc pouvoir manipuler la matrice SegmentsCommuns pour avoir en sortie :
Code:

1 2 3 4 SC1 = [1 11; 12 11; 12 2] % peu importe l'ordre des lignes et l'ordre des colonnes pour chaque ligne SC2 = [14 5; 14 6] SC3 = [9 16 ; 16 10]
Voyez-vous quelque chose pour m'aider parce que je ne trouve vraiment pas :( Ca m'aiderait vraiment beaucoup.

Je vous remercie d'avance.

Bernard

Finalement, je suis parvenu à trouver par moi-même :D

Pour ceux que ça intéresse, voici le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
SegmentsCommuns = [16 10; 6 14; 12 2; 1 11; 14 5; 11 12; 9 16]
 
% **** Mise en vecteur colonne des Segments communs
SegmentsCommuns2 = [SegmentsCommuns(:,1);SegmentsCommuns(:,2)];
% **** Récupération des indices
[iictttii,iiuii,iivii]=unique(SegmentsCommuns2,'rows');
% **** Histogramme du nombre de fois où chaque point apparait
% dans SegmentsCommuns
Histo = histc(iivii,[1:max(iivii)]);
% **** Liste des Points extrêmes
PE=find(Histo==1);
PointsExtremes = iictttii([PE])
 
PointsExtremesVar = PointsExtremes
 
PointSecond = 0;
SegmentsOK = [];
Segment1 = 0;
 
SegmentsCommunsP = SegmentsCommuns
i=1
 
 
while isempty (PointsExtremesVar) ~= 1
    SegmentsOK = []
    startPE = PointsExtremesVar(1,1) 
    Segment1 = 0;
 
    while isempty (Segment1) ~= 1
      Segment1 = SegmentsCommunsP(any(ismember(SegmentsCommunsP,startPE),2),:)
      SegmentsCommunsP =  SegmentsCommunsP(~all(ismember(SegmentsCommunsP,Segment1),2),:)
      SegmentsOK = [SegmentsOK;Segment1]
      SegmentsCommunsArray(i).sgtscommuns = SegmentsOK
      PointSecond = setdiff(Segment1, startPE)
      PointsExtremesVar = setdiff(PointsExtremesVar,startPE)
      startPE = PointSecond
    end
 
    i = i+1
end

NB : J'ai enregistré dans une structure les décompositions de SegmentsCommuns

:king: