Publicité
+ Répondre à la discussion
Page 8 sur 8 PremièrePremière ... 45678
Affichage des résultats 141 à 147 sur 147
  1. #141
    Rédacteur/Modérateur
    Avatar de pseudocode
    Homme Profil pro Xavier Philippeau
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    9 961
    Détails du profil
    Informations personnelles :
    Nom : Homme Xavier Philippeau
    Âge : 41
    Localisation : France, Hérault (Languedoc Roussillon)

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

    Informations forums :
    Inscription : décembre 2006
    Messages : 9 961
    Points : 15 082
    Points
    15 082

    Par défaut

    Citation Envoyé par saturn1 Voir le message
    PS: Ce qui est dommage avec l'exemple de ton code en java c'est qu'on ne peut pas placer les points initiaux.
    C'est juste un code d'exemple, ca n'est pas fait pour être utilisé en l'état sur des problèmes réels.

    Déjà, la résolution par schéma explicite est loin d'être fiable. Ensuite les énergies que j'ai choisi sont trop généralistes pour solutionner un problème concret.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  2. #142
    Membre éclairé

    Inscrit en
    janvier 2008
    Messages
    673
    Détails du profil
    Informations forums :
    Inscription : janvier 2008
    Messages : 673
    Points : 348
    Points
    348

    Par défaut

    Salut, quel contraintes te semblent pertinentes?(pour des vraies images pas des dessins a 3 couleurs ).

    J'ai vu le GVF, en existe-t-il d'autre pertinentes base sur la couleur ou autre critère intéressant?

    Merci.

  3. #143
    Rédacteur/Modérateur
    Avatar de pseudocode
    Homme Profil pro Xavier Philippeau
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    9 961
    Détails du profil
    Informations personnelles :
    Nom : Homme Xavier Philippeau
    Âge : 41
    Localisation : France, Hérault (Languedoc Roussillon)

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

    Informations forums :
    Inscription : décembre 2006
    Messages : 9 961
    Points : 15 082
    Points
    15 082

    Par défaut

    Citation Envoyé par saturn1 Voir le message
    Salut, quel contraintes te semblent pertinentes?(pour des vraies images pas des dessins a 3 couleurs ).

    J'ai vu le GVF, en existe-t-il d'autre pertinentes base sur la couleur ou autre critère intéressant?
    Hum...

    Je ne vois que 2 manières de faire intervenir les couleurs.
    - Dans l'energie du gradient de l'image, en calculant le gradient dans un espace de couleur (RGB, YUV, Lab, ...)
    - Dans une energie de contrainte, par exemple l'uniformité des zones intérieures/exterieures au contour.

    Si la définition des énergies devient trop compliqué pour faire converger le Snake, je te suggère de passer a d'autres méthodes de contours actifs, en particulier les Level-Sets.
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  4. #144
    Invité de passage
    Inscrit en
    avril 2008
    Messages
    5
    Détails du profil
    Informations forums :
    Inscription : avril 2008
    Messages : 5
    Points : 1
    Points
    1

    Par défaut

    Citation Envoyé par pseudocode Voir le message
    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 :
    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 :
    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 :
    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 :
    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.



    Salut, si tu peut mieux m'expliquer Les méthodes du mécanisme d'auto-adaptation, j'aimerai bien savoir quelle sont ces méthodes est ce que ce sont des méthode d'interpolation comme B-Spline puis ce que dans le code source je voit l'utilisation des coeffissions, merci de plus de détail.

  5. #145
    Invité de passage
    Homme Profil pro
    Inscrit en
    avril 2013
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : avril 2013
    Messages : 1
    Points : 1
    Points
    1

    Par défaut Snake

    Bonjour,

    J'ai testé le programme Snake que j'ai trouvé extrêmement intéressant pour mon application (approximation d'un contour par points, application en microscopie entra autres), bien plus simple (et largement suffisant) que des méthodes à base d'ondelettes.
    Problème : si j'arrive à lire le code java, je suis au niveau 0 pour l'écriture.
    J'ai essayé de le recharger sur Netbean, mais en vain.

    Pour lancer cette application telle-quelle comme une procédure externe à mon application il faudrait que je puisse en plus :
    1/ Passer le nom du fichier image en paramètre.
    2/ Récupérer la liste des points dans un fichier texte.
    3/ fermer Snake après écriture du fichier texte.
    Cette modif est elle très complexe à ajouter ?
    Qui pourrait m'aider éventuellement ?

    merci d'avance
    GF

  6. #146
    Rédacteur/Modérateur
    Avatar de pseudocode
    Homme Profil pro Xavier Philippeau
    Architecte système
    Inscrit en
    décembre 2006
    Messages
    9 961
    Détails du profil
    Informations personnelles :
    Nom : Homme Xavier Philippeau
    Âge : 41
    Localisation : France, Hérault (Languedoc Roussillon)

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

    Informations forums :
    Inscription : décembre 2006
    Messages : 9 961
    Points : 15 082
    Points
    15 082

    Par défaut

    Citation Envoyé par Gfanne Voir le message
    Pour lancer cette application telle-quelle comme une procédure externe à mon application il faudrait que je puisse en plus :
    1/ Passer le nom du fichier image en paramètre.
    2/ Récupérer la liste des points dans un fichier texte.
    3/ fermer Snake après écriture du fichier texte.
    Cette modif est elle très complexe à ajouter ?
    Qui pourrait m'aider éventuellement ?
    Il faut créer un nouveau JAR en remplacant la classe "SnkeGUI" par une nouvelle classe qui gère les entrées/sorties depuis la ligne de commande.

    Par exemple, un truc du genre:
    Code java :
    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
    public class SnakeCLI {
     
    	public void process(String[] args) throws Exception {
    		if (args.length<11)
    			throw new Exception("usage: java -jar SnakeCLI.jar imagefile 25 1.0 1.0 1.0 1.0 true 10 8 16 300");
     
    		String FILENAME  = args[0];
    		int    THRESHOLD = Integer.parseInt(args[1]); // in %
    		double ALPHA = Double.parseDouble(args[2]);
    		double BETA  = Double.parseDouble(args[3]);
    		double GAMMA = Double.parseDouble(args[4]);
    		double DELTA = Double.parseDouble(args[5]);
    		boolean AUTOADAPT    = Boolean.parseBoolean(args[6]);
    		int AUTOADAPT_LOOP   = Integer.parseInt(args[7]);
    		int AUTOADAPT_MINLEN = Integer.parseInt(args[8]);
    		int AUTOADAPT_MAXLEN = Integer.parseInt(args[9]);
    		int MAXITERATION     = Integer.parseInt(args[10]);
     
    		// chargement de l'image
    		BufferedImage image = loadimage(FILENAME);
    		int W = image.getWidth();
    		int H = image.getHeight();
     
    		// calcul du gradient et du gradient-flow
    		int[][] gradient = new int[W][H];
    		int[][] flow = new int[W][H];
    		computegflow(image, gradient, flow, THRESHOLD);
     
    		// point initiaux du snake
    		double radius = (W/2 + H/2) / 2;
    		double perimeter = 6.28 * radius;
    		int nmb = (int) (perimeter / 8);
    		Point[] circle = new Point[nmb];
    		for (int i = 0; i < circle.length; i++) {
    			double x = (W / 2 + 0) + (W / 2 - 2) * Math.cos((6.28 * i) / circle.length);
    			double y = (H / 2 + 0) + (H / 2 - 2) * Math.sin((6.28 * i) / circle.length);
    			circle[i] = new Point((int) x, (int) y);
    		}
     
    		// create snake instance
    		Snake snake = new Snake(W, H, gradient, flow, circle);
     
    		// snake base parameters
    		snake.alpha = ALPHA;
    		snake.beta  = BETA;
    		snake.gamma = GAMMA;
    		snake.delta = DELTA;
     
    		// snake extra parameters
    		snake.AUTOADAPT        = AUTOADAPT;
    		snake.AUTOADAPT_LOOP   = AUTOADAPT_LOOP;
    		snake.AUTOADAPT_MINLEN = AUTOADAPT_MINLEN;
    		snake.AUTOADAPT_MAXLEN = AUTOADAPT_MAXLEN;
    		snake.MAXITERATION     = MAXITERATION;
     
    		// compute final snake
    		int nmbloop = snake.loop();
    		if (nmbloop>=snake.MAXITERATION)
    			throw new Exception("Snake does not converge!");
     
    		// print snake points to console
    		for(Point p:snake.snake)
    			System.out.printf("%d %d\n",p.x,p.y);
    	}
     
    	// Load the image to process
    	private  BufferedImage loadimage(String filename) throws Exception {
    		File file = new File(filename);
    		return ImageIO.read(file);
    	}
     
    	// compute the gradient and the gradient-flow
    	private void computegflow(BufferedImage image, int[][] gradient, int[][] flow, int THRESHOLD) {
    		int W = image.getWidth();
    		int H = image.getHeight();
     
    		// GrayLevelScale (Luminance)
    		int[][] clum = new int[W][H];
    		for (int y = 0; y < H; y++)
    			for (int x = 0; x < W; x++) {
    				int rgb=image.getRGB(x,y);
    				int r = (rgb >>16 ) & 0xFF;
    				int g = (rgb >> 8 ) & 0xFF;
    				int b = rgb & 0xFF;
    				clum[x][y] = (int)(0.299*r + 0.587*g + 0.114*b);  
    			}
     
    		// Gradient (sobel)
    		int maxgradient=0;
    		for (int y = 0; y < H-2; y++)
    			for (int x = 0; x < W-2; x++) {
    				int p00 = clum[x+0][y+0]; int p10 = clum[x+1][y+0]; int p20 = clum[x+2][y+0];
    				int p01 = clum[x+0][y+1]; /*-------------------- */ int p21 = clum[x+2][y+1];
    				int p02 = clum[x+0][y+2]; int p12 = clum[x+1][y+2]; int p22 = clum[x+2][y+2];
    				int sx = (p20+2*p21+p22)-(p00+2*p01+p02);
    				int sy = (p02+2*p12+p22)-(p00+2*p10+p10);
    				int snorm = (int)Math.sqrt(sx*sx+sy*sy);
    				gradient[x+1][y+1]=snorm;
    				maxgradient=Math.max(maxgradient, snorm);
    			}
     
    		// thresholding
    		boolean[][] binarygradient = new boolean[W][H];
    		for (int y = 0; y < H; y++)
    			for (int x = 0; x < W; x++)
    				if (gradient[x][y] > THRESHOLD*maxgradient/100) {
    					binarygradient[x][y]=true;
    				} else {
    					gradient[x][y]=0;
    				}
     
    		// distance map to binarized gradient
    		double[][] cdist = new ChamferDistance(ChamferDistance.chamfer5).compute(binarygradient, W,H);
    		for (int y = 0; y < H; y++)
    			for (int x = 0; x < W; x++)
    				flow[x][y]=(int)(5*cdist[x][y]);
    	}
     
    	public static void main(String[] args) throws Exception {
    		new SnakeCLI().process(args);
    	}
    }

    Au final, ca permet d'executer le code et de récupérer les points via une commande:
    java -jar snake.jar imagefile 25 1.0 1.0 1.0 1.0 true 10 8 16 300 > result.txt
    ALGORITHME (n.m.): Méthode complexe de résolution d'un problème simple.

  7. #147
    Invité de passage
    Inscrit en
    novembre 2006
    Messages
    3
    Détails du profil
    Informations forums :
    Inscription : novembre 2006
    Messages : 3
    Points : 3
    Points
    3

    Par défaut

    bonjour,

    est ce que vous pouvez me donner les differentes methodes de segmentation d'image, c'est trés urgante , car je doit choisir 4 méthodes a étudier pour mon projets de fin d'étude.

    moi je connaise selement : les snakes classiques, les GVF , levels sets , les contours actifs genetiques.

    mon chef de projet ma déconsier de les etudier , et je doit trouver d'autre méthode ,

    merci d'avance.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •