Discussion :

[Palca]

Bonjour,
j'ai des difficultés à effectuer une composition de fonctions de types spécifiques pour effectuer du dessin, que voici :

Code :

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

1
2
3
4
5
type Point == float * float;;
type 'a Image == Point -> 'a;;
type Region == bool Image;;
type Transform == Point -> Point;;
type Vector == float * float;;

Les fonctions des transformations d'images sont les suivantes :

Code :

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

1
2
3
let (translateP : Vector -> Transform) = fun (dx,dy) (x,y) -> (x+.dx,y+.dy);;
let (scaleP : Vector -> Transform) = fun (sx,sy) (x,y) -> (x*.sx,y*.sy);;
let (uscaleP : float -> Transform) = fun s -> scaleP (s,s);;

Et mon dessin est défini par ces fonctions :

Code :

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

1
2
let distO (x,y) = sqrt (x*.x+.y*.y);;
let (udisk : Region) = fun (x,y) -> (distO (x,y)) < 1.;;

Mon problème est d'arriver à appliquer mes fonctions de transformations à mon dessin. La fonction d'application de transformation doit forcément être typée de la sorte :

Code :

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

applyTrans : Transform -> 'a Image -> 'a Image

J'ai effectué plusieurs essais tels que :

Code :

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

1
2
let (applyTrans : Transform -> 'a Image -> 'a Image) = fun trans im -> trans (im);;
let (applyTrans : Transform -> 'a Image -> 'a Image) = fun trans im -> im (trans);;

ou encore

Code :

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

let (applyTrans : Transform -> 'a Image -> 'a Image) = fun (trans param) (im (xi,yi)) -> im (trans param (xi,yi));;

mais ça ne fonctionne pas, d'où ma question ici.

En fait je coince surtout ou niveau du passage de paramètres, car les fonctions de transformations prennent en paramètres un vecteur ou un flottant puis le point à transformer, et la fonction de dessin dépend du point qui doit être transformé par la fonction correspondante.

Merci d'avance.

[alex_pi]

T'as regardé du coté de la transformation inverse ?

[Palca]

Non, pour cette fonction je dois faire sans (c'est pour un projet à rendre, j'ai des contraintes).

[alex_pi]

Non, pour cette fonction je dois faire sans (c'est pour un projet à rendre, j'ai des contraintes).

Le seul moyen de voir si un point est dans la région transformée, c'est de voir si l'antécédant de ce point était dans la région non transformée. Il me semble très peu probable que tu puisses te passer de la transformation réciproque.

[Palca]

Voici une partie du texte sur lequel je dois me baser :

In computer graphics, spatial transforms are commonly represented by matrices, and hence are restricted to special classes like linear, affine, or projective.
Application of transformations is implemented as a matrix/vector multiplication, and composition as matrix/matrix multiplication. In fact, this representation is so common that transforms are often thought of as being matrices.
A simpler and more general point of view, however, is that transforms are simply space-to-space functions:
type Transform = Point * Point
It is then easy to define the familiar affine transforms:
type Vector = (Float, Float)
translateP :: Vector -> Transform
translateP (dx, dy) (x, y) = (x + dx, y + dy)
scaleP :: Vector -> Transform
scaleP (sx, sy) (x, y) = (sx × x, sy × y)
uscaleP :: Float -> Transform — uniform
uscaleP s = scaleP (s, s)
rotateP :: Float -> Transform
rotateP theta (x, y) = (x × cos theta - y × sin theta ,y × cos theta + x × sin theta)
By definition, transforms map points to points. Can we ‘apply’ them, in some sense, to map images into transformed images?
applyTrans :: Transform -> Image a -> Image a
A look at the definitions of the Image and Transform types suggests the following
simple definition:
applyTrans xf im ?= im · xf — wrong
udisk :: Region
udisk p = distO p < 1
Notice that the uscaleP-composed udisk is half rather than twice the size of udisk. (Similarly, udisk · translateP (1, 0) moves udisk to the left rather than right.) The reason is that uscaleP 2 maps input points to be twice as far from the origin, so points have to start out within 1/2 unit of the origin in order for their scaled counterparts to be within 1 unit.
In general, to transform an image, we must inversely transform sample points before feeding them to the image being transformed:
applyTrans xf im = im · xf -1
While this definition is simple and general, it has the serious problem of requiring inversion of arbitrary spatial mappings. Not only is it sometimes
difficult to construct inverses, but also some interesting mappings are manyto-one and hence not invertible. In fact, from an image-centric point-of-view, we only need the inverses and not the transforms themselves. For these reasons, we simply construct the transforms in inverted form, and do not use applyTrans.

Donc en effet il est écrit que la fonction applyTrans n'est pas très pratique et la suite du texte décrit des fonctions bien plus performantes mais je dois quand coder la fonction applyTrans pour vérifier son fonctionnement.

[alex_pi]

Voici une partie du texte sur lequel je dois me baser :

Donc en effet il est écrit que la fonction applyTrans n'est pas très pratique et la suite du texte décrit des fonctions bien plus performantes mais je dois quand coder la fonction applyTrans pour vérifier son fonctionnement.

Le texte dit *exactement* ce que je disais, à savoir qu'il te faut l'inverse de la transformation \o/