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.