IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Contribuez Discussion :

[image] Snake (contour actif)


Sujet :

Contribuez

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut [image] Snake (contour actif)
    Voici une implémentation Java de l'algorithme "Snake" (contour actif).

    L'algorithme Snake permet de tracer le contour d'une zone irrégulière en déformant progressivement une courbe de départ. Pour plus d'informations, je vous conseille l'article de khayyam90.




    La classe Snake (attributs+constructeur)
    Code java : 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
     
    public class Snake {
     
    	// Points of the snake
    	private List<Point> snake;
     
    	// Length of the snake (euclidean distance)
    	private double snakelength=0;
     
    	// size of the image (and of the 2 arrays below)
    	private int width=0,height=0;
     
    	// gradient value (modulus)
    	private int[][] gradient;
     
    	// gradient flow (modulus)
    	private int[][] flow;
     
    	// 3x3 neighborhood used to compute energies
    	private double[][] e_uniformity = new double[3][3];
    	private double[][] e_curvature  = new double[3][3];
    	private double[][] e_flow       = new double[3][3];
    	private double[][] e_inertia    = new double[3][3];
     
    	// auto add/remove points to the snake
    	// according to distance between points
    	private boolean AUTOADAPT=true;
    	private static int AUTOADAPT_LOOP=10;
    	private static int AUTOADAPT_MINLEN=8;
    	private static int AUTOADAPT_MAXLEN=16;
     
    	// maximum number of iterations (if no convergence)
    	private static int MAXITERATION = 1000;
     
    	// coefficients for the 4 energy functions
    	public double alpha=1.1, beta=1.2, gamma=1.5, delta=3.0;
     
    	// alpha = coefficient for uniformity (high => force equals distance between points)
    	// beta  = coefficient for curvature  (high => force smooth curvature)
    	// gamma  = coefficient for flow      (high => force gradient attraction)
    	// delta  = coefficient for intertia  (high => get stuck to gradient)
     
    	/**
             * Constructor
             *
             * @param width,height size of the image and of the 2 following arrays
             * @param gradient gradient (modulus)
             * @param flow gradient flow (modulus)
             * @param points inital points of the snake
             */
    	public Snake(int width, int height, int[][] gradient, int[][] flow, Point... points) {
    		this.snake = new ArrayList<Point>(Arrays.asList(points));
    		this.gradient = gradient;
    		this.flow = flow;
    		this.width = width;
    		this.height = height;
    	}
     
     
    	// add here the other methods.
     
    }

    Les méthodes de l'algorithme "snake"
    Code java : 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
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
     
    /**
     * main loop
     * 
     * @return the final snake
     */
    public List<Point> loop() {
    	int loop=0;
     
    	while(step() && loop<MAXITERATION) {
    		// auto adapt the number of points in the snake
    		if (AUTOADAPT && (loop%AUTOADAPT_LOOP)==0) {
    			removeOverlappingPoints(AUTOADAPT_MINLEN);
    			addMissingPoints(AUTOADAPT_MAXLEN);
    		}
    		loop++;
    	}
     
    	// rebuild using spline interpolation
    	if (AUTOADAPT) rebuild(AUTOADAPT_MAXLEN);
     
    	return this.snake;
    }
     
    /**
     * update the position of each point of the snake
     *
     * @return true if the snake has changed, otherwise false.
     */
    private boolean step() {
    	boolean changed=false;
    	Point p = new Point(0,0);
     
    	// compute length of original snake (used by method: f_uniformity)
    	this.snakelength = getsnakelength();
     
    	// compute the new snake
    	List<Point> newsnake = new ArrayList<Point>(snake.size());
     
    	// for each point of the previous snake
    	for(int i=0;i<snake.size();i++) {
    		Point prev = snake.get((i+snake.size()-1)%snake.size());
    		Point cur  = snake.get(i);
    		Point next = snake.get((i+1)%snake.size());
     
    		// compute all energies
    		for(int dy=-1;dy<=1;dy++) {
    			for(int dx=-1;dx<=1;dx++) {
    				p.setLocation(cur.x+dx, cur.y+dy);
    				e_uniformity[1+dx][1+dy] = f_uniformity(prev,next,p);
    				e_curvature[1+dx][1+dy]  = f_curvature(prev,p,next);
    				e_flow[1+dx][1+dy]       = f_gflow(cur,p);
    				e_inertia[1+dx][1+dy]    = f_inertia(cur,p);
    			}
    		}
     
    		// normalize energies
    		normalize(e_uniformity);
    		normalize(e_curvature);
    		normalize(e_flow);
    		normalize(e_inertia);
     
    		// find the point with the minimum sum of energies
    		double emin = Double.MAX_VALUE, e=0;
    		int x=0,y=0;
    		for(int dy=-1;dy<=1;dy++) {
    			for(int dx=-1;dx<=1;dx++) {
    				e = 0;
    				e+= alpha * e_uniformity[1+dx][1+dy]; // internal energy
    				e+= beta  * e_curvature[1+dx][1+dy];  // internal energy
    				e+= gamma * e_flow[1+dx][1+dy];       // external energy
    				e+= delta * e_inertia[1+dx][1+dy];    // external energy
     
    				if (e<emin) { emin=e; x=cur.x+dx; y=cur.y+dy; }
    			}
    		}
     
    		// boundary check
    		if (x<1) x=1;
    		if (x>=(this.width-1)) x=this.width-2;
    		if (y<1) y=1;
    		if (y>=(this.height-1)) y=this.height-2;
     
    		// compute the returned value
    		if (x!=cur.x || y!=cur.y) changed=true;
     
    		// create the point in the new snake
    		newsnake.add(new Point(x,y));
    	}
     
    	// new snake becomes current
    	this.snake=newsnake;
     
    	return changed;
    }
     
    // normalize energy matrix
    private void normalize(double[][] array3x3) {
    	double sum=0;
    	for(int i=0;i<3;i++)
    		for(int j=0;j<3;j++)
    			sum+=Math.abs(array3x3[i][j]);
     
    	if (sum==0) return;
     
    	for(int i=0;i<3;i++)
    		for(int j=0;j<3;j++)
    			array3x3[i][j]/=sum;
    }
     
    private double getsnakelength() {
    	// total length of snake
    	double length=0;
    	for(int i=0;i<snake.size();i++) {
    		Point cur   = snake.get(i);
    		Point next  = snake.get((i+1)%snake.size());
    		length+=distance2D(cur, next);
    	}
    	return length;
    }
     
    private double distance2D(Point A, Point B) {
    	int ux = A.x-B.x;
    	int uy = A.y-B.y;
    	double un = ux*ux+uy*uy;
    	return Math.sqrt(un);
    }

    Les méthodes des fonctions d'energie:
    Code java : 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
     
    private double f_uniformity(Point prev, Point next, Point p) {
     
    	// length of previous segment
    	double un = distance2D(prev, p);
     
    	// mesure of uniformity
    	double avg = snakelength/snake.size();
    	double dun = Math.abs(un-avg);
     
    	// elasticity energy
    	return dun*dun;
    }
     
    private double f_curvature(Point prev, Point p, Point next) {
    	int ux = p.x-prev.x;
    	int uy = p.y-prev.y;
    	double un = Math.sqrt(ux*ux+uy*uy);
     
    	int vx = p.x-next.x;
    	int vy = p.y-next.y;
    	double vn = Math.sqrt(vx*vx+vy*vy);
     
    	if (un==0 || vn==0) return 0;
     
    	double cx = (vx+ux)/(un*vn);
    	double cy = (vy+uy)/(un*vn);
     
    	// curvature energy
    	double cn = cx*cx+cy*cy;
    	return cn;
    }
     
    private double f_gflow(Point cur, Point p) {
    	// gradient flow
    	int dcur = this.flow[cur.x][cur.y];
    	int dp   = this.flow[p.x][p.y];
    	double d = dp-dcur;
    	return d;
    }
     
    private double f_inertia(Point cur, Point p) {
    	double d = distance2D(cur, p);
    	double g = this.gradient[cur.x][cur.y];
    	double e = g*d;
    	return e;
    }

    Les méthodes du mécanisme d'auto-adaptation:
    Code java : 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
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
     
    // rebuild the snake using cubic spline interpolation
    private void rebuild(int space) {
     
    	// precompute length(i) = length of the snake from start to point #i
    	double[] clength = new double[snake.size()+1];
    	clength[0]=0;
    	for(int i=0;i<snake.size();i++) {
    		Point cur   = snake.get(i);
    		Point next  = snake.get((i+1)%snake.size());
    		clength[i+1]=clength[i]+distance2D(cur, next);
    	}
     
    	// compute number of points in the new snake
    	double total = clength[snake.size()];
    	int nmb = (int)(0.5+total/space);
     
    	// build a new snake
    	List<Point> newsnake = new ArrayList<Point>(snake.size());
    	for(int i=0,j=0;j<nmb;j++) {
    		// current length in the new snake
    		double dist = (j*total)/nmb;
     
    		// find corresponding interval of points in the original snake
    		while(! (clength[i]<=dist && dist<clength[i+1])) i++;
     
    		// get points (P-1,P,P+1,P+2) in the original snake
    		Point prev  = snake.get((i+snake.size()-1)%snake.size());
    		Point cur   = snake.get(i);
    		Point next  = snake.get((i+1)%snake.size());
    		Point next2  = snake.get((i+2)%snake.size());
     
    		// do cubic spline interpolation
    		double t =  (dist-clength[i])/(clength[i+1]-clength[i]);
    		double t2 = t*t, t3=t2*t;
    		double c0 =  1*t3;
    		double c1 = -3*t3 +3*t2 +3*t + 1;
    		double c2 =  3*t3 -6*t2 + 4;
    		double c3 = -1*t3 +3*t2 -3*t + 1;
    		double x = prev.x*c3 + cur.x*c2 + next.x* c1 + next2.x*c0;
    		double y = prev.y*c3 + cur.y*c2 + next.y* c1 + next2.y*c0;
    		Point newpoint = new Point( (int)(0.5+x/6), (int)(0.5+y/6) );
     
    		// add computed point to the new snake
    		newsnake.add(newpoint);
    	}
    	this.snake = newsnake;
    }
     
     
    private void removeOverlappingPoints(int minlen) {
    	// for each point of the snake
    	for(int i=0;i<snake.size();i++) {
    		Point cur = snake.get(i);
     
    		// check the other points (right half)
    		for(int di=1+snake.size()/2;di>0;di--) {
    			Point end  = snake.get((i+di)%snake.size());
    			double dist = distance2D(cur,end);
     
    			// if the two points are to close...
    			if ( dist>minlen ) continue;
     
    			// ... cut the "loop" part og the snake
    			for(int k=0;k<di;k++) snake.remove( (i+1) %snake.size() );
    			break;
    		}
    	}
    }
     
    private void addMissingPoints(int maxlen) {
    	// for each point of the snake
    	for(int i=0;i<snake.size();i++) {
    		Point prev  = snake.get((i+snake.size()-1)%snake.size());
    		Point cur   = snake.get(i);
    		Point next  = snake.get((i+1)%snake.size());
    		Point next2  = snake.get((i+2)%snake.size());
     
    		// if the next point is to far then add a new point
    		if ( distance2D(cur,next)>maxlen ) {
     
    			// precomputed Uniform cubic B-spline for t=0.5
    			double c0=0.125/6.0, c1=2.875/6.0, c2=2.875/6.0, c3=0.125/6.0;
    			double x = prev.x*c3 + cur.x*c2 + next.x* c1 + next2.x*c0;
    			double y = prev.y*c3 + cur.y*c2 + next.y* c1 + next2.y*c0;
    			Point newpoint = new Point( (int)(0.5+x), (int)(0.5+y) );
     
    			snake.add( i+1 , newpoint ); i--;
    		}
    	}
    }


    Utilisation:

    Le constructeur de la classe Snake a besoin des paramètres suivants:

    • int width,height: la taille de l'image (et des deux tableaux suivants)
    • int[][] gradient: un tableau contenant la norme du gradient pour chaque pixel [x][y]
    • int[][] flow: un tableau contenant la norme du vecteur de flux pour chaque pixel [x][y].
      En pratique, on peut utiliser la carte des distances jusqu'au pic de gradient le plus proche
    • Point... points: la liste des points constituant le snake initial


    La méthode publique "loop()" fait évoluer le snake jusqu'a convergence et retourne la liste des points du snake final.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  2. #2
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    L'implémentation sous forme d'un JAR executable: snake.jar

    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  3. #3
    Membre émérite Avatar de b_reda31
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Avril 2007
    Messages
    899
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : Algérie

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2007
    Messages : 899
    Par défaut
    Bonjour,
    Tout d'abord merci PseudoCode pour cette contribution,c'est exactement ce que je cherchais...
    J'essais d'implémenter cette algorithme en utilisant C++ Builder.
    Mais je ne suis pas arrivé à comprendre la procédure f_gflow
    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    private double f_gflow(Point cur, Point p) {
        // gradient flow
        int dcur = this.flow[cur.x][cur.y];
        int dp   = this.flow[p.x][p.y];
        double d = dp-dcur;
        return d;
    }
    Que représente flow, est ce la carte des distances de l'image du gradient binarisée ?


    -Concernant la fonction gradient(i,j),je l'ai implémenter de cette façon :
    gradient(i,j)=sqrt(gradientX(i,j)²+gradientY(i,j)²)
    Tq:

    gradientX(i,j)=ABS(valeur_pixel(i+1,j)-valeur_pixel(i-1,j))
    &
    gradientY(i,j)=ABS(valeur_pixel(i,j+1)-valeur_pixel(i,j-1))

    Est ce la bonne méthode de calcul du gradient?!

  4. #4
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par b_reda31 Voir le message
    Bonjour,
    Tout d'abord merci PseudoCode pour cette contribution,c'est exactement ce que je cherchais...
    Heureux que cela serve à quelqu'un. J'en profite pour citer ici l'article de khayyam90 qui sert de support à cette contribution.

    Que représente flow, est ce la carte des distances de l'image du gradient binarisée ?
    oui, c'est exactement cela.

    -Concernant la fonction gradient(i,j),je l'ai implémenter de cette façon :
    gradient(i,j)=sqrt(gradientX(i,j)²+gradientY(i,j)²)
    Tq:

    gradientX(i,j)=ABS(valeur_pixel(i+1,j)-valeur_pixel(i-1,j))
    &
    gradientY(i,j)=ABS(valeur_pixel(i,j+1)-valeur_pixel(i,j-1))

    Est ce la bonne méthode de calcul du gradient?!
    C'est une définition qui en vaut une autre. Personnellement j'utilise plutôt un noyau SOBEL ou MDIF, mais c'est une question d'habitude.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  5. #5
    Membre émérite Avatar de b_reda31
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Avril 2007
    Messages
    899
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : Algérie

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2007
    Messages : 899
    Par défaut
    Citation Envoyé par pseudocode Voir le message
    Heureux que cela serve à quelqu'un. J'en profite pour citer ici l'article de khayyam90 qui sert de support à cette contribution.
    J'ai lu dans cet article (II-4 Paragraphe 3)que le nombre de points dans le snake peut augmenter selon la taille du snake !!

    à quel moment et comment ajoute t on un point?

    PS:Je ne sais pas si je suis au bon endroit pour poser cette question,si ce n'est pas le cas je m'en excuse...

  6. #6
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par b_reda31 Voir le message
    J'ai lu dans cet article (II-4 Paragraphe 3)que le nombre de points dans le snake peut augmenter selon la taille du snake !!

    à quel moment et comment ajoute t on un point?
    Dans la boucle principale "loop()", si le mode auto-adaptation est activé (AUTOADAPT=true) alors on vérifie la forme du snake toutes les N itérations (N = AUTOADAPT_LOOP).

    L'auto-adaptation est composée de 2 phases:
    - Si 2 points sont trop près: suppression de l'un des 2 ( méthode removeOverlappingPoints() )
    - Si 2 points sont trop éloignés: ajouts de points entre les 2 ( méthode addMissingPoints() )
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  7. #7
    Membre émérite Avatar de b_reda31
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Avril 2007
    Messages
    899
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : Algérie

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2007
    Messages : 899
    Par défaut
    Bonjour,J'ai une petite question concernant la normalisation des énergies

    Citation Envoyé par pseudocode Voir le message
    Code java : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    // normalize energy matrix
    private void normalize(double[][] array3x3) {
        double sum=0;
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
                sum+=Math.abs(array3x3[i][j]);
     
        if (sum==0) return;
     
        for(int i=0;i<3;i++)
            for(int j=0;j<3;j++)
                array3x3[i][j]/=sum;
    }
    Cette normalisation sert à rendre toutes les valeur des trois énergies dans l'intervalle [ 0 , 1 ],et cela afin de ne pas favoriser une énergie par rapport à une autre.Est ce bien cela?
    Si oui,est ce que ça reviendrait au même de diviser chaque sous-matrice d'énergie par sa plus grande valeur? Bien entendu les valeur ne seront pas les mêmes mais les "proportions" entre énergies seront conservées.

  8. #8
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par b_reda31 Voir le message
    Cette normalisation sert à rendre toutes les valeur des trois énergies dans l'intervalle [ 0 , 1 ],et cela afin de ne pas favoriser une énergie par rapport à une autre.Est ce bien cela?
    oui, c'est cela.

    Si oui,est ce que ça reviendrait au même de diviser chaque sous-matrice d'énergie par sa plus grande valeur?
    Heu... en théorie oui, on peut utiliser n'importe quelle mesure.

    Dans ton cas, ca voudrait dire utiliser la distance Linfinie = max(abs(x)). Je n'ai jamais testé.

    Dans mon code j'utilise la distance L1 = sum(abs(x))
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  9. #9
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2007
    Messages
    51
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2007
    Messages : 51
    Par défaut
    encore une toute dernière questions sur ce code...
    Sur quelle théorie s'appuie le calcule de la courbure ? je n'arrive pas bien à saisir le sens des calculs..
    Merci !

  10. #10
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par galadorn Voir le message
    encore une toute dernière questions sur ce code...
    Sur quelle théorie s'appuie le calcule de la courbure ? je n'arrive pas bien à saisir le sens des calculs..
    Merci !
    Oui, j'avoue que c'est assez étrange comme formule. Je ne me souviens plus trop comment j'en suis arrivé là, mais ca ne doit pas être très orthodoxe.

    Ca ressemble à une dérivée seconde discrète, avec des points de sampling non uniforme.

    http://fr.wikipedia.org/wiki/Dérivée_seconde_discrète
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  11. #11
    Membre averti
    Profil pro
    Inscrit en
    Octobre 2007
    Messages
    51
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Octobre 2007
    Messages : 51
    Par défaut
    hehe merci !
    Sinon je me disait aussi que l'énergie de courbure pouvait être approchée par la distance que fait le point par rapport au barycentre des points de son voisinage (donc le milieu du segment Pprev et Pnext dans le cas de la 2D). Mais il reste quelque chose qui me chiffonne dans cette faàon d'exprimer l'énergie de courbure : si le point P est situé sur le segment, mais pas au milieu, l'énergie de courbure voudra le faire déplacer vers le milieu du segment, alors que sa courbure sera nulle. Donc si elle est calculée comme ça, son effet accentuera l'effet de l'énergie de continuité, ce que je ne veux pas vraiment.

  12. #12
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par b_reda31 Voir le message
    En d'autres terme je dirais que contrairement aux autres énergie (Curvature et Externe) je ne vois pas l'influence de l'énergie d'uniformité sur la déformation du Snake.
    Cette energie empeche que les points du snake s'agglutinent autour d'un meme point de fort gradient, et assure ainsi que les points soient répartis sur tout le périmètre du snake.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  13. #13
    Membre émérite Avatar de b_reda31
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Avril 2007
    Messages
    899
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : Algérie

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2007
    Messages : 899
    Par défaut
    Bonjour,
    Merci Merci et Merci PseudoCode Pour toute l'aide que vous m'avez apporté au sujet des contours actifs.
    Comme je voulais déjà dis,c'est (les contours actifs) mon thème de fin d'étude et sans votre aide,je ne sais pas si j'aurai pu autant avancer...ou plutôt je ne pense pas.

    En ce moment je suis entrain de me préparer pour ma soutenance,j'essaie d'imaginer toutes les questions que pourront me poser les membres du jury,et ça me fais stressé ,mais bon,grâce à vous je maitrise relativement bien ce que je vais exposer.

    Il y a une question qui est susceptible de m'être poser,cela concerne la forme du contour initial,pourquoi un cercle?
    La réponse qui me vient à la tête est la suivante:
    Puisque le processus de déformation consiste à minimiser l'énergie,la forme de cercle pour le contours initiale a été choisi car un cercle dispose d'une énergie interne minimale (pas de point anguleux) ce qui réduira le nombre d'itération lors du processus de déformation.
    J'ajouterai aussi qu'avec une autre forme (rectangle par ex) de contours initial le résultat peut être le même mais la convergence vers l'objet d'intérêt se fera avec un nombre plus élevé d'itération.


    Que pensez vous de cette réponse?

  14. #14
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par b_reda31 Voir le message
    Puisque le processus de déformation consiste à minimiser l'énergie,la forme de cercle pour le contours initiale a été choisi car un cercle dispose d'une énergie interne minimale (pas de point anguleux) ce qui réduira le nombre d'itération lors du processus de déformation.

    Que pensez vous de cette réponse?
    Hum... Je ne suis pas bien sûr que le "nombre d'itérations" soit une réponse valable.

    C'est plutôt que l'algo du snake résout l'équation énergétique itérativement avec un "schéma explicite" (google). Ce genre de résolution est très sensible aux brusques changements, ce qui implique:

    1. de prendre un "pas" de résolution très petit (= le pixel, voir moins)
    2. d'eviter les brusques changements de valeurs dans les énergies

    C'est le point n°2 qui fait préferer le cercle car, comme tu l'as dit, les delta des energies internes autour d'un voisinage sont faibles (le cercle etant une solution de l'equation sans contraintes externes).

    L'idéal etant aussi de limiter les changements de valeurs des energies externes, par exemple en prenant une forme de départ qui "ressemble" à la forme finale.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  15. #15
    Membre émérite Avatar de b_reda31
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Avril 2007
    Messages
    899
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : Algérie

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Avril 2007
    Messages : 899
    Par défaut
    Citation Envoyé par pseudocode Voir le message

    L'idéal etant aussi de limiter les changements de valeurs des energies externes, par exemple en prenant une forme de départ qui "ressemble" à la forme finale.
    J'avais penser à une solution de ce genre,où l'utilisateur peut initialiser (dessiner) un contour manuellement autour de l'objet,ça serait l'idéal comme vous dites.J'essaierai d'ajouter une option "Initialisation avancée" dans mon application .
    Merci encore

  16. #16
    Membre habitué
    Inscrit en
    Février 2009
    Messages
    9
    Détails du profil
    Informations forums :
    Inscription : Février 2009
    Messages : 9
    Par défaut La Force Interne
    Je vous remercie, Monsieur pseudocode, pour cette illustration, J'ai lu tout ce débat sur les contours actifs, il est vraiment m'aidé beaucoup
    J'ai quelques questions concernant la force interne.

    Le code pour calculer la force continuité et la force courbure
    Code java : 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
     
    private double f_uniformity(Point prev, Point next, Point p) {
     
    	// length of previous segment
    	double un = distance2D(prev, p);
     
    	// mesure of uniformity
    	double avg = snakelength/snake.size();
    	double dun = Math.abs(un-avg);
     
    	// elasticity energy
    	return dun*dun;
    }
     
    private double f_curvature(Point prev, Point p, Point next) {
    	int ux = p.x-prev.x;
    	int uy = p.y-prev.y;
    	double un = Math.sqrt(ux*ux+uy*uy);
     
    	int vx = p.x-next.x;
    	int vy = p.y-next.y;
    	double vn = Math.sqrt(vx*vx+vy*vy);
     
    	if (un==0 || vn==0) return 0;
     
    	double cx = (vx+ux)/(un*vn);
    	double cy = (vy+uy)/(un*vn);
     
    	// curvature energy
    	double cn = cx*cx+cy*cy;
    	return cn;
    }

    Le code est écrit pour les contours actifs fermer,
    Ma question est dans le cas des contours actifs ouvert,
    Est-ce qu'on met la force continuité = 0 pour le 1er point
    Et la force coubure =0 pour le 1er et le dernier point?
    Puisque dans le cas d'un contour actif ouvert il n'y a pas de précédent pour le premier point; et il n'y a pas le point suivant pour le dernier point.
    MERCI D'avance Mr PseudoCode

  17. #17
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par Faudel24000 Voir le message
    Le code est écrit pour les contours actifs fermer,
    Ma question est dans le cas des contours actifs ouvert,
    Est-ce qu'on met la force continuité = 0 pour le 1er point
    Et la force coubure =0 pour le 1er et le dernier point?
    Puisque dans le cas d'un contour actif ouvert il n'y a pas de précédent pour le premier point; et il n'y a pas le point suivant pour le dernier point.
    MERCI D'avance Mr PseudoCode
    Je n'ai pas testé le cas des contours ouverts mais ca me semble une bonne idée de mettre ces deux énergies à 0 pour le premier et le dernier point.

    Il faudra également modifier le mécanisme d'auto-adaptation si vous comptez l'utiliser car le calcul utilise le fait que la courbe est fermée.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  18. #18
    Membre averti
    Étudiant
    Inscrit en
    Avril 2009
    Messages
    51
    Détails du profil
    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Avril 2009
    Messages : 51
    Par défaut
    Bonsoir
    j'ai besoin de cet algorithme malheureusement je travaille sur matlab ;je ne sais pas si il y' a un moyen pour faire la liaison de matlab et java et je ne sais pas vraiment comment exécuter cet algorithme dans le netbeans???
    si vous pouvez m'indiquez la procédure de l'exécuter j'en serais reconnaissante
    merci

  19. #19
    Rédacteur
    Avatar de pseudocode
    Homme Profil pro
    Architecte système
    Inscrit en
    Décembre 2006
    Messages
    10 062
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 52
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Architecte système
    Secteur : Industrie

    Informations forums :
    Inscription : Décembre 2006
    Messages : 10 062
    Par défaut
    Citation Envoyé par aichaeside Voir le message
    Bonsoir
    j'ai besoin de cet algorithme malheureusement je travaille sur matlab ;je ne sais pas si il y' a un moyen pour faire la liaison de matlab et java
    Je ne connais pas assez Matlab pour être sur, mais ca m'étonnerait qu'on puisse faire faciliement une interop Matlab/Java. D'un autre coté, je suis certain qu'on doit pouvoir trouver sur le net une implémentation des "Contours Actifs" en matlab.

    et je ne sais pas vraiment comment exécuter cet algorithme dans le netbeans??? si vous pouvez m'indiquez la procédure de l'exécuter j'en serais reconnaissante
    Il y a un fichier "*.jar" dispo dans le post #2. Il suffit de le télécharger et de l'executer (double-clic si java est installé).
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  20. #20
    Rédacteur/Modérateur

    Avatar de Jerome Briot
    Homme Profil pro
    Freelance mécatronique - Conseil, conception et formation
    Inscrit en
    Novembre 2006
    Messages
    20 317
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Freelance mécatronique - Conseil, conception et formation

    Informations forums :
    Inscription : Novembre 2006
    Messages : 20 317
    Par défaut
    Citation Envoyé par pseudocode Voir le message
    Je ne connais pas assez Matlab pour être sur, mais ca m'étonnerait qu'on puisse faire faciliement une interop Matlab/Java.
    Si si => http://www.mathworks.com/support/sol...n=1-179EJ&BB=1

    Citation Envoyé par pseudocode Voir le message
    je suis certain qu'on doit pouvoir trouver sur le net une implémentation des "Contours Actifs" en matlab.
    Par exemple => 2D/3D image segmentation toolbox

Discussions similaires

  1. Réponses: 1
    Dernier message: 08/09/2012, 08h07
  2. Réponses: 1
    Dernier message: 06/05/2011, 16h16
  3. Snake : contours actifs
    Par gilsub dans le forum Traitement d'images
    Réponses: 5
    Dernier message: 24/04/2011, 13h15
  4. [Débutant] Snake (contour actif) pour les images
    Par ikrame dans le forum C++Builder
    Réponses: 2
    Dernier message: 07/01/2011, 11h33

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo