Discussion :

[manimouleLight&Magic]

Bonjour à tous,

Je fais mes premiers pas en c# (ces dernières années, je me suis fait les dents sur du C++), et je dois faire une application multitouch.
Pour symboliser mes besoins, prenons l'exemple classique de manipulation de photos:
dans les exemples que j'ai trouvé sur le net, il est pratiquement toujours question d'utiliser une matrice pour coder les transformation du renderTransform associé à l'image. C'est très bien, mais j'ai besoin, à terme, de récupérer les coordonnées de mon objet sous forme de transformation scale, rotation, et translation.


j'ai donc représenté mon image en xaml de cette façon:

Code xml :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
<UserControl blablabla...>
    <Image Name="nom" Source="{Binding Path=ImagePath}" Stretch="Fill" Width="100" Height="100" RenderTransformOrigin="0.5, 0.5">
        <Image.RenderTransform>
            <TransformGroup>
                <TranslateTransform x:Name="ajustement"/>
                <ScaleTransform ScaleX="{Binding Path=ScaleX}" ScaleY="{Binding Path=ScaleY}"></ScaleTransform>
                <RotateTransform Angle="{Binding Path=Angle}" />
                <TranslateTransform x:Name="reajustement"/>
                <TranslateTransform X="{Binding Path=X}" Y="{Binding Path=Y}" />
            </TransformGroup>
        </Image.RenderTransform>
    </Image>
</UserControl>

et dans le code, j'ai

Code c# :

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
 
private void Manip_delta(object sender, ManipulationDeltaEventArgs e)
{
         var element = e.OriginalSource as UIElement;
 
            ajustement.X = -e.ManipulationOrigin.X+this.X;
            ajustement.Y = -e.ManipulationOrigin.Y+this.Y;
            reajustement.X = -ajustement.X;
            reajustement.Y = -ajustement.Y;
            this.Angle += e.DeltaManipulation.Rotation;
 
            this.X += e.DeltaManipulation.Translation.X;
            this.Y += e.DeltaManipulation.Translation.Y;
 
            this.imageBuilding.Width *= e.DeltaManipulation.Scale.X;
            this.imageBuilding.Height *= e.DeltaManipulation.Scale.Y; 
            //j'attaque directement les dimensions de l'image parce que pour une raison qui m'échappe, les attributs scaleX et scaleY sont sans effet sur mon image... si quelqu'un a une idée...
 
            e.Handled = true;
}

Ca fonctionne, mais à l'utilisation, un gros décalage se fait entre mes doigt et l'image, comme si il y avait un problème dans les centres de mes transformations.... Je comprends pas bien pourquoi, puisque je prends même la peine de réajuster mon objet en fonction du centre de la manip...

quelqu'un a une idée? parce que là, je sèche...

Merci !

[Thomas Lebrun]

Je ne comprend pas vraiment ce que tu veux dire mais sache que les modifciations sur le RenderTransform ne modifie que le Visuel. Si tu veux que tes modifications impacte réellement la taille du contrôle, tu dois le faire au niveau du LayoutTransform.


A+

[manimouleLight&Magic]

oui effectivement, j'ai pas été hyper clair:

alors en fait je crée une application qui me permet de manipuler des images dans un canvas (déplacer, tourner et/ou zoomer, comme on voit souvent sur les démonstrations de tables multitouch)
cette application, je compte la synchroniser avec un autre programme (en opengl), qui m'affichera exactement la même chose.

Mon problème: mon programme opengl ne doit recevoir que des informations de type:
-position
-rotation
-scale

il est donc plus cohérent que mon application WPF gère le renderTransform avec ces 3 transformations plutôt qu'avec une matrice.
J'ai donc réalisé le code visible dans mon premier message. A priori, ça fonctionne.

MAIS

quand je lance mon programme et que je manipule mes images, il apparait très vite un léger décalage entre mes images et mes doigts. J'en déduit qu'il y a un problème quelque part dans mon code c#.

Quand je me contente de déplacer mon image avec un seul doigt, aucun problème. Mais dés que j'essaie de les tourner ou de zoomer, mon image part complètement en vrille, comme si la rotation (ou le scale) était centré sur un point aléatoire du canvas plutot que sur mes doigts

pour ce qui est du renderTransform vs LayoutTransform, à priori, je pense que ça pose pas de problème. Du moment que je peux récupérer ces données pour les envoyer à mon autre programme, peu m'importe que ce soit des données purement visuelles


C'est un problème idiot, j'en suis sûr, mais je perds du temps bêtement là dessus, pas moyen d'y voir clair. help

merci

[manimouleLight&Magic]

bon alors j'ai du nouveau:

le canvas dans lequel j'ai placé mes images est manipulable également (Comme ça, on peut zoomer sur le plan de travail et continuer à manipuler les images naturellement)
Or, il semble que ça pose problème: ma manipulation d'images fonctionne correctement SAUF si je déplace ou redimensionne le canvas.

C'est dans ce cas là que mes transformations se retrouvent excentrées par rapport à mes doigts

J'en conclus donc que pour hierarchiser mes controles, il faut que je prenne en compte ces transformations appliquées au canvas.

Ca ne résoud toujours pas le problème, mais au moins, le chmilblik avance...