Discussion :

[sisi231]

Bonjour,
Je suis nouveau en C++, bien que j'ai un peu potassé le tuto du site des zéro.
Je précise que mon travail doit être réalisé sous Visual Studio Community 2015.
J'ai a réaliser une DLL qui utilisera des fonctions d'OpenCV qui est je ne crois pas me tromper en C++ natif.
Le but de cette application est de calculer les axes des spores de champignons sur photo d'après :
- un objet BITMAP qui est l'image de départ
- les coordonnées du curseur à l'endroit où l'on a cliqué
je dois m'occupper du calcul des axes mais c'est dans la partie wrapper que j'aurais besoin d'aide.
Si vous voulez le code VB fonctionnant est :

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
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
 
Imports System.Drawing
 
''' <summary>
''' Définition des deux axes de la spore
''' </summary>
Public Class DEUXAXESCPP
    Public axe1() As Tuple(Of Double, Double)
    Public axe2() As Tuple(Of Double, Double)
End Class
 
 
 
Public Class Spore
 
    '-------------------------------------------------------------
    ' DLL en VB.Net
    ' Simule une DLL en C++.
    ' Le C++ ne possède pas de classe PointF compatible avec .NET
    ' On remplace le PointF par un Tuple de double
    ' Un axe possède deux points donc deux Tuples
    '
    '-------------------------------------------------------------
 
 
    ''' <summary>
    ''' Facteur d'échelle
    ''' </summary>
    Public Shared Property Echelle As Double = 1.0
 
 
    ''' <summary>
    ''' Simulation de la DLL de reconnaissance de forme
    ''' </summary>
    ''' <param name="Org">PointF : Point origine à l'intérieur de la spore</param>
    ''' <param name="Img">Image contenant une ou plusieurs spores</param>
    ''' <returns></returns>
    Public Shared Function GetAxes(ByVal Org As PointF, ByVal Img As Bitmap) As DEUXAXESCPP
        Dim Valeur As New DEUXAXESCPP
 
        ' Grand axe 
        ' ici on définit arbitrairement un axe horizontal de +/- 50 pixels / origine
        Valeur.axe1 = {New Tuple(Of Double, Double)(Org.X - 50, Org.Y), New Tuple(Of Double, Double)(Org.X + 50, Org.Y)}
        ' Petit axe perpendiculaire
        ' ici on définit arbitrairement un axe vertical de +/- 20 pixels / origine
        Valeur.axe2 = {New Tuple(Of Double, Double)(Org.X, Org.Y - 20), New Tuple(Of Double, Double)(Org.X, Org.Y + 20)}
 
        Return Valeur
    End Function
 
End Class

Après je dois remplacer ce code bidon (pour les tests) par deux fichiers : l'un en C++ natif qui fera le travail de reconnaissance de formes (ma DLL), l'autre en C++/CLI un wrapper avec une application VB.net.
J'ai lu plusieurs tutoriels sur Internet mais je n'y arrive pas tout seul.
Voici mes codes pour l'instant :
le code "bidon" = temporaire de test en C++ natif
GestSporesNatif.h

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
23
24
25
26
27
28
29
30
31
#pragma once
class Spore {
public:
 
	//-------------------------------------------------
	//---- Fonction d'analyse d'image en C++ natif ----
	//-------------------------------------------------
	//     Img : Image à analyser
	//    x, y : Coordonnées du point d'analyse sur l'image
	double* ChercheAxes(BITMAP Img, double x, double y)
	{
		double*** res;
		res[0] = new double*[2];
		res[1] = new double*[2];
		res[0][0] = new double[2];
		res[0][1] = new double[2];
		res[1][0] = new double[2];
		res[1][1] = new double[2];
		res[0][0][0] = x - 50;
		res[0][0][1] = y;
		res[0][1][0] = x + 50;
		res[0][1][1] = y;
		res[1][0][0] = x;
		res[1][0][1] = y-20;
		res[1][1][0] = x;
		res[1][1][1] = y+20;
 
		return (double*) res;
	}
 
};

GetSporesNatif.cpp

Code :

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

1
2
3
4
5
// GetSporesNatif.cpp*: définit les fonctions exportées pour l'application DLL.
//
 
#include "stdafx.h"
#include "GetSporesNatif.h"

le code en C++/CLI de mon wrapper qui ne fonctionne pas :
Wrapper.h

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
// ClassLibrary1.h
 
#pragma once
#include "../GetSporesNatif/GetSporesNatif.h"
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Drawing;
namespace Wrapper {
 
	public ref class DEUXAXESCPP
	{
	public:
		DEUXAXESCPP(void) {};
		property IList<Tuple<Double, Double>^>^ axe1;
		property IList<Tuple<Double, Double>^>^ axe2;
	};
 
}

Wrapper.cpp

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
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
#include "stdafx.h"
 
#include "wrapper.h"
 
#include <vcclr.h>
 
namespace Wrapper {
 
	public ref class Spore
	{
 
	public:
		static property Double Echelle;
		static DEUXAXESCPP^ GetAxes(Bitmap^ Img, Double x, Double y);
 
	};
 
	public ref class Wrapper {
 
	public:
		Wrapper();
 
		~Wrapper();
		Wrapper()
		{
 
			spore = new Spore();
 
		}
 
 
 
		~Wrapper()
 
		{
 
			delete spore;
 
		};
		DEUXAXESCPP^ GetAxes(Bitmap^ Img, Double x, Double y)
		{
			DEUXAXESCPP^ Valeur = gcnew(DEUXAXESCPP);
			spore.GetAxes(Img, x, y);
 
 
			return Valeur;
		}
	private:
 
		Spore spore;
	};
};

Merci de votre aide.
Bien cordialement.

[Médinoc]

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
	double* ChercheAxes(BITMAP Img, double x, double y)
	{
		double*** res;
		res[0] = new double*[2];
		res[1] = new double*[2];
		res[0][0] = new double[2];
		res[0][1] = new double[2];
		res[1][0] = new double[2];
		res[1][1] = new double[2];
		res[0][0][0] = x - 50;
		res[0][0][1] = y;
		res[0][1][0] = x + 50;
		res[0][1][1] = y;
		res[1][0][0] = x;
		res[1][0][1] = y-20;
		res[1][1][0] = x;
		res[1][1][1] = y+20;
 
		return (double*) res;
	}
;

What.

que...

je ne même...

---

PS: Tu ne devrais pas avoir à définir DEUXAXESCPP dans les deux langages. Surtout que tu sembles hésiter entre faire de axe1 et axe2 des champs ou des propriétés...

[bacelar]

Je suis nouveau en C++, bien que j'ai un peu potassé le tuto du site des zéro.

Bin, t'es bon pour tout réapprendre correctement, ce tuto est l'un des plus mauvais qui m'été donné de survoler.
Le forum du même site regorge d'explication sur ce fait que ce tuto est horrible et de lien vers un cours de C++ Moderne.

Faire un wrapper entre 2 technologies implique une connaissance assez poussée dans ces 2 technologies, et là, vous êtes clairement pas encore au niveau, ni dans l'une ni dans l'autre.

Toutes les remarques de @Médinoc sont plus que pertinentes.

Vous ne devriez pas avoir un seul pointeur nu dans votre code natif (alors de code à base de ***, même pas dans un cauchemar de l'apocalypse).
Regardez du coté des pointeurs intelligents.
OpenCV a une API en C, c'est à vous de faire un wrapper (1 de plus ) C/C++.

On instance une classe managée (.NET, "ref") avec gcnew et on appelle jamais directement delete, ni en managé ni en natif (grâce aux pointeurs intelligents).

[sisi231]

Bonjour,
Donc je sens que l'opération va être compliquée donc si je comprends bien il me faut maîtriser :
- le C (là j'ai quelques connaissances)
- le C++ natif (là pas grand chose à vrai dire)
- le C++/CLI (là rien)
- le VB.NET (là rien)
- savoir créer un wrapper entre le C et le C++ natif (là rien)
- savoir créer un wrapper entre le C++ natif et le VB.NET (là rien)
ça fait beaucoup !!
l'application VB.NET ce n'est pas moi qui l'ai codé
je dois créer une DLL en C++ avec OpenCV (car d'après leur site ils supportent bien le C++ natif)
et le point noir c'est de créer un "pont" entre cette DLL et l'interface de l'application VB.NET.
Même si c'est une tâche ardue, auriez-vous quelques lectures du plus simple au plus compliqué pour m'aider à progresser ?
Merci de votre aide.

[bacelar]

Bon, après une petite balade avec Google, l'API officielle d'OpenCV, c'est du C++ et pas su C, un wrapping de moins.
Si vous maitrisez le C++/CLI vous n'aurez pas besoin de connaitre le VB.NET, vous aurez le même "vocabulaire" que les développeurs VB.NET (et tout autre langage .NET).

Mais le fait de connaitre le C avant le C++ est un gros inconvénient, car beaucoup de pratique du C ne sont pas les bonnes en C++.

En C++ moderne, on n'utilise quasiment jamais de pointeurs nus (les pointeurs à la C) mais quasi-exclusivement des pointeurs intelligents.

Je vous conseille donc d'apprendre le C++ moderne (C++11/14) donc n'utilisez ni de vieux bouquin ni des trucs qui demande à connaitre le C avant le C++.

Pour faire du C++/CLI, il faut connaitre avant le C++, de préférence moderne.

Si l'API d'OpenCV est assez bien conçue / simple (pas de pointeur en paramètre, par de fonction de callback, etc...) vous n'aurez qu'à créer des classe managées (ref class) donc visible par le code VB.NET qui seront du copier-coller des classes OpenCV au niveau de l'API (méthodes) et qui ne feront que passe-plats entre le code VB et OpenCV.

Attention à ne pas négliger l'apprentissage d'une bibliothèque comme OpenCV, qui peut être bien plus long que le C++ lui-même.

[Mat.M]

Donc je sens que l'opération va être compliquée donc si je comprends bien il me faut maîtriser :

comme Médinoc le suggère je crois que revoir les allocations mémoires ça s'impose vraiment

sinon si tu ne veux pas te casser la tête avec des tableaux statiques il vaut mieux utiliser les conteneurs du C++ et de la STL comme std::list,std::vector...à toi de voir celui qui est le plus adapté.
C'est pas si compliqué que ça à utiliser et ça simplifie le code