Discussion :

[bibi9]

Hello,

J'aimerais savoir quelle serais le meilleur moyen pour placer des chaises automatiquement autour d'une table?

comme ceci:

http://img521.imageshack.us/my.php?i...07copiegw6.png

Ceci d'une manière automatique (si plus de chaise, alors diminuer leurs tailles etc..)

(l'affichage est fait avec des coordonnées)

D'avance merci.

[Zavonen]

Suppose d'abord que ta table est ronde et que tes chaises soient carrées de taille fixe. Le problème est aussi simple que Souviron le dit.
Tu calcules donc les positions des centres des chaises Pn.
Après, tu appliques globalement une affinité d'axe x'Ox et de rapport b/a où 2a est le grand axe de la table et 2b le petit axe.
Tu appliques cette affinité à la table elle-même et aux points Pn, MAIS PAS AUX CHAISES qui seraient déformées.
Pour amener la chaise Pi en place tu fais une rotation de la chaise P0 d'angle P0Pi suivie d'une translation de façon à avoir une isométrie donc pas de déformation.

[pseudocode]

Je suis déçu. J'attendais une formule barbare à base de fonctions elliptiques inverses, afin d'avoir l'équidistance entre les chaises.

[bibi9]

Je suis déçu. J'attendais une formule barbare à base de fonctions elliptiques inverses, afin d'avoir l'équidistance entre les chaises.

C'était l'idée que j'avais en tête, mais rien que d'y penser j'ai commencer à stresser un peut..

J'avais commencé à faire quelques chose de ce style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
//les participants seront placés tout les IncrementPlace
double incrementPlace = 360 / nbParticipants;
double placeDegre = 0;
 
for (int i = 1; i <= nbParticipants; i++)
{
 messagebox("Siege" + i " place en angle" +  placeDegre );
 placeDegre += incrementPlace;
}

ce qui me donne le degré de rotation de chaque chaise

après pour les placer au bon endroits.. j'avais pensé faire avec l'équation paramétrique du cercle..

Mais je n'ai pas bien compris ton explication

Après, tu appliques globalement une affinité d'axe x'Ox et de rapport b/a où 2a est le grand axe de la table et 2b le petit axe.
Tu appliques cette affinité à la table elle-même et aux points Pn, MAIS PAS AUX CHAISES qui seraient déformées.
Pour amener la chaise Pi en place tu fais une rotation de la chaise P0 d'angle P0Pi suivie d'une translation de façon à avoir une isométrie donc pas de déformation.

[Zavonen]

Une affinité consiste à réduire ou augmenter seulement une coordonnée (par exemple x ou y dans le cas du plan).
Supposons que ton grand axe soit 2a et ton petit axe 2b. Pour faire une affinité de rapport b/a à tout point M(x,y) tu associes le point M'(x, by/a).
Ce faisant une table de rayon a se déforme en un ovale (une ellipse).
Fais un dessin avec b=a/2 et tu vas comprendre tout de suite.
Mais il ne faut pas le faire aux chaises (le confort pourrait s'en ressentir).

[bibi9]

Ok,ok.. !

mais ce que j'avais en tête c'était plutôt une taille fixe pour la table
et des chaises qui changent de tailles selon le nombre de personnes (plus y a de personnes plus les chaises deviennent petite histoire de caser tout le monde autour de la table)

[Zavonen]

mais ce que j'avais en tête c'était plutôt une taille fixe pour la table

c'est bien ce que j'avais compris. Ta table est fixe, mais sur ta figure elle est ovale. La réduction des chaises je ne l'ai pas encore abordée.
Quand tes points Pi sont répartis autour de la table tu calcules le minimum des distances PiPi+1 soit m.
Si ta chaise est à base carrée, pour une marge te sécurité tu prends la diagonale du carré delta. tu compares m et delta.
Tu appliques un coeff réducteur à ton image de chaise pour que delta <2m/3 et voilà.

[pseudocode]

Ok,ok.. !

mais ce que j'avais en tête c'était plutôt une taille fixe pour la table
et des chaises qui changent de tailles selon le nombre de personnes (plus y a de personnes plus les chaises deviennent petite histoire de caser tout le monde autour de la table)

Dans ce cas, tu peux calculer le perimetre de l'ellipse sur laquelle seront placées les chaises (cf. approx. de Ramanujan) et diviser par le nombre de chaises. Ca te donne la distance inter-chaise "D" (et donc la taille des chaises)

Ensuite tu utilises l'equation parametrique de cette ellipse pour te déplacer le long du périmetre. A chaque fois que tu t'es déplacé d'une longueur "D" sur ce perimetre (approx. euclidienne ou autre) tu places une chaise.

[Zavonen]

Oui, Pseudocode a (encore) raison.
Des chaises équidistantes sur une table ronde, ne le sont plus après application d'une affinité (ce n'est pas une isométrie).
Il faut donc passer par les abscisses curvilignes, les approx, etc...
Avec un truc comme ça on court-circuite la théorie:

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
import math
 
#paramètres de l'ellipse
a,b=2,1
 
def Point (t):
    global a,b
    return a*math.cos(t),b*math.sin(t)
 
def Distance (P1,P2):
    return math.sqrt((P1[0]-P2[0])*(P1[0]-P2[0]) + (P1[1]-P2[1])*(P1[1]-P2[1]))
 
def PerimEllipse(pas):
    result=0
    t=0
    while t<math.pi*2:
        result+=Distance(Point(t),Point(t+pas))
        t+=pas
    return result
 
def main():
    print PerimEllipse(0.01)
 
if __name__ == '__main__':
    main()

[millie]

En voyant le titre du sujet, je croyais que c'était un problème de placement de table en fonction des affinités des gens... Mais c'est moins marrant en fait

[souviron34]

En voyant le titre du sujet, je croyais que c'était un problème de placement de table en fonction des affinités des gens... Mais c'est moins marrant en fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
si belle-mère et cousin
   alors incompatibles
sinon
  si tonton et soeurette
       alors coup de gueule
sinon
  si Fred et Phil
      alors bourrage de g.e.le
sinon
...
 
fin si

[Zavonen]

Voici une implémentation de la méthode suggérée par Pseudocode avec numpy et matplotlib:

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
# -*- coding: cp1252 -*-
 
import numpy as np
import matplotlib.pyplot as plt
#paramètres du pb
a=2 #demi grand axe de la table
b=1 #demi petit axe
step=0.001 # le step
chaises=6 # le nombre de chaises
P=0 #paramètre de l'ellipse
D= 0 #distance interchaises
Places=[]
# valeurs du paramètre
t=np.arange(0,2*np.pi,0.001)
 
#paramétrage de l'ellipse
def cx(t):
    global a
    return a*np.cos(t)
def cy(t):
    global b
    return b*np.sin(t)
 
def Point (t):
    return cx(t),cy(t)
 
def Distance (P1,P2):
    return np.sqrt((P1[0]-P2[0])*(P1[0]-P2[0]) + (P1[1]-P2[1])*(P1[1]-P2[1]))
 
def PerimEllipse():
    global step,P,D,chaises
    P=0
    t=0
    while t<np.pi*2:
        P+=Distance(Point(t),Point(t+step))
        t+=step
    D=P/chaises
 
def MarquePoints():
    global step,P,D,chaises,Places
    P=0
    t=0
    AppOK=False
    while t<np.pi*2:
        if P/D-int(P/D)>0.5:
            AppOK=True
        P+=Distance(Point(t),Point(t+step))
        t+=step
        if -0.01<=(P/D - int(P/D)) <=0.01 and AppOK:
            Places.append(Point(t))
            AppOK=False
 
# calcul du périmètre
PerimEllipse()
MarquePoints()
# tracé de l'ellipse
plt.plot (cx(t),cy(t))
# marquage des places
for s in Places:
    plt.plot([0,s[0]],[0,s[1]])
#tracé des axes
plt.plot([-2,2],[0,0],'w')
plt.plot([0,0],[-2,2],'w')
#voir
plt.show()

[bibi9]

Merci beaucoup de vos réponses !

c'est bien ce que j'avais compris. Ta table est fixe, mais sur ta figure elle est ovale

Arg.. Erreur de ma part...pour simplifier je voulais faire avec un Cercle.

J'avais fait un petit bout avant que tu poste ton code pyton.

voici ce que j'avais fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//Sert a savoir quelle sera en degré l'angle de chaque place...
double incrementPlace = 360 / nbParticipants;
double placeDegre = 0;
 
//perimetre du cercle
double Perimetre = 2 * Math.PI * rayon;
 
//espacement entre chaque chaise
double interChaise = Perimetre / nbParticipants;
 
for (int i = 1; i <= nbParticipants; i++)
{
            X = rayon* Cos(placeDegre);
            Y = rayon* Sin(placeDegre);
 
        tailleImage(interChaise);
        angleImage(placeDegre)
 
        //donc si il y a 4 chaises la première aura l angle 0°
       // la 2eme l'angle 90 °, la 3eme 180° etc..
       placeDegre += incrementPlace 
}

Avec ceci j'obtiens des choses pas mal

Si je comprend bien ton code Zavonen, tu fait pratiquent pareille, excepté le calcule du Périmètre et le placement des chaises "manuellement" ?