Je vous présente mon code :

const float size_init = 0.06; 
const float focal = 0.0036; 
double distance; 

// 2 array de 2 tq 

int code_f[2]; 
int code_e[2]; 

// Remplissage des deux array 
.....
...
..
.

distance = (double)(size_init/(code_f[1]-code_e[1]*focal));

Lors de l'affichage de distance, c'est un entier qui apparait et non un float, une idée ? merci

Il faut convertir : `static_cast<float>(code_f[1])". Idem pour "code_e"

Et pas besoin de pré-déclarer "distance".

Tuson a écrit:

Lors de l'affichage de distance, c'est un entier qui apparait et non un float, une idée ? merci

L'erreur doit être dans une partie du code que tu ne nous montres pas. Il n'y a aucune raison que le résultat soit un entier !

rouIoude a écrit:

Tuson a écrit:

Lors de l'affichage de distance, c'est un entier qui apparait et non un float, une idée ? merci

L'erreur doit être dans une partie du code que tu ne nous montres pas. Il n'y a aucune raison que le résultat soit un entier !

(tu me mets le doute )

Pourquoi faire des trantypages (cast) ? Sur une expression comme celle ci ils sont normalement implicites.

Il ne devrait pas y avoir de soucis sur ce code pour moi non plus,
- float*int => float.

- int+float*int => float

- float/(int + float*int) => float

Et du coup, pourquoi mélanger avec des doubles? Les machines aiment moyennement les mélanges (pour les perfs), est-ce bien nécessaire?

il n'y a aucun problème d'entier dans le code que tu donnes. La chose à savoir est que si une opération utilise des types différents, il y a conversion du plus "simple" vers le type de l'autre.

Mais ton cast en double ne fait peut-être pas ce que tu penses. Ici tout est effectué en float et le résultat final sera converti en double, donc on ne bénéficie pas de la précision de calcul du double. Pour avoir cela il faudrait écrire par exemple:

double  distance = size_init / (code_f[1] - (double)code_e[1]*focal);

Ici le compilateur converti en double code_e[1], donc doit convertir en double focal pour obtenir un produit de double. Ensuite pour la soustraction code_f[1] doit être converti en double, et donc on divise par un double. Finalement il faut convertir en double size_init pour faire une division de double.

(les constantes en doubles, c'est bien aussi du coup...)

Merci pour vos réponses et je sais bien que  normalement distance devrait faire une vonversion implicite vers float.. Mais... Et puis j'ai essayé avec la méthode distance = static_cast<float>... Et ça ne fonctionne toujours pas..

J'ai mis tous mes double en float, pour éviter les mélanges aussi

Et pour info,voici ma liste code_e et code_f.

A partir de cette liste je fais directement le calcul donc je ne vois pas ou pourrait être l'erreur...

-
Edité par Tuson 27 octobre 2021 à 8:13:34

Tuson a écrit:

A partir de cette liste je fais directement le calcul donc je ne vois pas ou pourrait être l'erreur...

Et bien moi non plus, pour la simple et bonne raison que je ne vois pas le code ! Mais l'erreur est surement dans le code !

code_e[0] = hull[0].x + D_x; 
code_e[1] = hull[0].y + D_y; 

code_f[0] = hull[1].x + D_x; 
code_f[1] = hull[1].y + D_y;

Où D_x et D_y est de type int

hull est un std::vector<cv::Point>

Rien de plus n'y est fait sur les variables code_e et code_f.

On a bien compris que tes tableaux code_f et code_e était des tableaux d'entiers (int) ! l'erreur n'est pas ici !

#include <iostream>
#include <string.h>
#include "code.hpp" 
#include "real_size.hpp"
#include "dist.hpp"
#include "threshold.hpp"
#include <sstream>
#include <stdio.h>
#include <vector>
#include <algorithm>


using namespace cv;


Mat img_thresh;
Mat img_crop;
Mat img_copy;

std::ofstream logfile("_logfile.txt",std::ios::out);




// INIT //
int cpt = 3;

int detected = 0; 

int i = 1; 
int j = 1;

char* chaine = "QR Code détecté"; 
char chaine_temp;

std::vector<Point>location; 
std::vector<Point>hull;



int code_e[2]; 
int code_f[2]; 
int code_g[2]; 
int code_h[2]; 





int left;
int top;
int width; 
int height;

int D_x;
int D_y;


float size_init = 0.06;
float focal = 0.0036;
float pxl_size = 0.0000014;
float distance ; 

Mat img_clone; 

// COEUR // 
int main(int argc, char* argv[])
{

	Mat img = imread("Testqr180.jpg");
	
	int largeur = (img.size().width);
	int hauteur = round (img.size().height);
	
	
	
	
	logfile<<" : hauteur = "<<std::to_string(hauteur);
	logfile<<" : largeur = "<<std::to_string(largeur)<<std::endl;
	
	while (detected !=1){
		
		int pxl_carre = round(largeur/cpt);
			
	
		int it_largeur = round(largeur/pxl_carre);
		int it_hauteur = round(hauteur/pxl_carre);
	
	
		left = 0;
		top = 0;
		width = pxl_carre*125/100;
		height = pxl_carre*125/100;
	
		int last_it_largeur = largeur - width;
		int last_it_hauteur = hauteur - height;
	
	
	
		logfile<<" : it_largeur = "<<std::to_string(it_largeur);
		logfile<<" : it_hauteur = "<<std::to_string(it_hauteur)<<std::endl;
		logfile<<" : pxl_carre = "<<std::to_string(pxl_carre)<<std::endl;
		logfile<<" : width = "<<std::to_string(width);
		logfile<<" : height = "<<std::to_string(height)<<std::endl;
		logfile<<" : last_it_largeur = "<<std::to_string(last_it_largeur);
		logfile<<" : last_it_hauteur = "<<std::to_string(last_it_hauteur)<<std::endl;
		i = 1; 
		j = 1;
		
	
		while(j<= it_hauteur and detected == 0)
		{ 
			/*cout<<" j = "<<j<<endl;
			cout<<" i = "<<j<<endl;*/
			logfile<<"  "<<std::endl;
		
		
			if (i == it_largeur + 1 ) {
				i = 1 ;
				
				std::cout<<" i end plus plsu plus  = "<<i<<std::endl;
			}
		
		
			
			while( i<= it_largeur and detected == 0)
			{
				std::cout<<" j = "<<j<<std::endl;
				std::cout<<" i = "<<i<<std::endl;
				std::cout<<"left : "<<left<<std::endl;
				std::cout<<"top : "<<top<<std::endl;
				Rect crop(left,top,width,height);
				img_crop =img(crop);
				std::cout<<"crop"<<std::endl;
			
				logfile<<" i = "<<std::to_string(i); 
				logfile<<" : j = "<<std::to_string(j);
				logfile<<" : left = "<<std::to_string(left);
				logfile<<" : top = "<<std::to_string(top);
			
				/*ostringstream name; 
				name<<"file_im"<<j<<"."<<i<<".jpg";
				imwrite(name.str(), img_crop);*/
				
				
				//cout<<"before"<<endl;
				scan(img_crop,img_copy,detected,*chaine,hull);
				//cout<<"after"<<endl;
				if (detected==1){
					std::cout<<"Chaine"<<std::endl;
					std::cout<<"hull : "<<hull<<std::endl;
					D_x = left; 
					D_y = top;
					
					
					/*const char *temp = chaine_temp;
					cout<<"Temp"<<*temp<<endl;*/
					
				}
				
				logfile<<" : detected = "<<std::to_string(detected)<<std::endl;

				
			
				if (i == (it_largeur -1) ){
					left = last_it_largeur;
				}
				
				else
					left +=pxl_carre;
			
				i++;
				std::cout<<" i_end = "<<i<<std::endl;
				
			}
		
					
			if (j < it_hauteur){
				left = 0; 
				top += pxl_carre; 
			}
		
			if (j == it_hauteur - 1) {
				top = last_it_hauteur;
				left = 0; 
			}
			j++;
		}
		cpt++;	
		i=0;
		j=0;	
	}
		
		
	img_clone = img.clone();		
	realsize(img_clone,code_e,code_f,code_g,code_h, hull,D_x, D_y);	
	
	
	logfile<<" code_e = [ "<<std::to_string(code_e[0]); 
	logfile<<", "<<std::to_string(code_e[1]); 
	
	logfile<<" ] : code_f = [ "<<std::to_string(code_f[0]);
	logfile<<", = "<<std::to_string(code_f[1]);
	
	logfile<<" ] : code_g = [ "<<std::to_string(code_g[0]);
	logfile<<", "<<std::to_string(code_g[1]);
	
	logfile<<" ] : code_h = [ "<<std::to_string(code_h[0]);
	logfile<<", "<<std::to_string(code_h[1]);
	logfile<<" ] "<<std::endl;
	
	
	
	dist(code_e,code_f,code_g,code_h, size_init,focal,distance,pxl_size);
	std::cout<<"distance : "<<dist<<std::endl;
	
	
	
		/*scan(img,img_copy,detected); 
		imwrite("test_end.jpg", img_copy);
		cout<<"scan_end"<<endl;
		cout<<"Size"<<img_copy.size()<<endl;*/
	

	
	
	
	
	
	
	
	
		/*binary(img,img_thresh);
		imwrite("test.jpg", img_thresh);
		cout<<"Size_thresh"<<img_thresh.size()<<endl;*/
	
	
	
	
	
	return 0;
}

 realsize.cpp

#include "real_size.hpp"

using namespace cv;

void realsize(cv::Mat &img_clone,int code_e[2],int code_f[2],int code_g[2],int code_h[2], std::vector<cv::Point>&hull,int &D_x, int &D_y)
{
	std::cout<<"hull_x : "<<hull[0].x<<std::endl;
	std::cout<<"D_x : "<<D_x<<std::endl; 
	std::cout<<"D_y : "<<D_y<<std::endl;		
	
	/*code_e[0] = hull[1].x + D_x; 
	code_e[1] = hull[1].y + D_y; 
	
	code_f[0] = hull[2].x + D_x; 
	code_f[1] = hull[2].y + D_y; */
	
	
	code_e[0] = hull[0].x + D_x; 
	code_e[1] = hull[0].y + D_y; 
	
	code_f[0] = hull[1].x + D_x; 
	code_f[1] = hull[1].y + D_y;
	
	std::cout<<"code_e : "<<code_e[0]<<std::endl; 
	std::cout<<"code_e : "<<code_e[1]<<std::endl; 	
	std::cout<<"code_f : "<<code_f[0]<<std::endl;		
	std::cout<<"code_f : "<<code_f[1]<<std::endl;	
	
	code_g[0] = hull[2].x + D_x; 
	code_g[1] = hull[2].y + D_y; 
	
	code_h[0] = hull[3].x + D_x; 
	code_h[1] = hull[3].y + D_y; 		
			
	
		
	Point p1(code_e[0],code_e[1]), p2(code_f[0],code_f[1]);	
	Point p3(code_g[0],code_g[1]), p4(code_h[0],code_h[1]);	
	
	
	line(img_clone,p1,p2,Scalar(255,0,0), 3,LINE_MAX);	
	line(img_clone,p2,p3,Scalar(255,0,0), 3,LINE_MAX);
	line(img_clone,p3,p4,Scalar(255,0,0), 3,LINE_MAX);
	line(img_clone,p4,p1,Scalar(255,0,0), 3,LINE_MAX);
	
	
	imwrite("clone.jpg", img_clone);
}

dist.cpp

#include "dist.hpp" 

using namespace cv; 

void dist(int code_e[2],int code_f[2],int code_g[2],int code_h[2], float size_init,float focal,float distance,float pxl_size)
{
	/*double f = code_f[1]+0.0; 
	double e = code_e[1]+0.0;
	std::cout<<"f : "<<f<<std::endl;*/
	
	
	
	std::cout<<"cooooode_f : "<<code_f[1]<<std::endl;
	
	float div = (float)(code_f[1]-code_e[1]);
	
	std::cout<<"div : "<<div<<std::endl;
	distance =(focal * size_init /((float)((code_f[1])-(code_e[1]))*pxl_size));
	
	
	
}

Vous avez tout !

Tuson a écrit:

Lors de l'affichage de distance, c'est un entier qui apparait et non un float, une idée ? merci

Tu calcules distance à la ligne 18 de dist.cpp mais tu ne l'affiches pas. Comment tu vois que c'est un entier qui apparaît ?

(distance est une variable locale à la fonction dist).

PS : Je n'avais pas vu :

    dist(code_e,code_f,code_g,code_h, size_init,focal,distance,pxl_size);
    std::cout<<"distance : "<<dist<<std::endl;

Là, c'est l'adresse de la fonction que tu affiches !

Il faudrait revoir tes bases avant de t'attaquer à des codes conséquents !

-
Edité par rouIoude 27 octobre 2021 à 11:00:15

ok je viens de voir ! Ce n'est pas un soucis de bases ! Juste la tête dans le guidon comme on dit et je n'ai pas fait attention au nom de mes variables ! MErci pour votre aide à tous !

Tuson a écrit:

Ce n'est pas un soucis de bases ! Juste la tête dans le guidon comme on dit et je n'ai pas fait attention au nom de mes variables ! 

Il n'y a pas que le noms des variables !

Dans ta fonction dist, pourquoi avoir mis distance en paramètre alors que tu ne l'utilise qu'en local ?

et si tu veux utiliser le résultat de distance à l’extérieur de la fonction ne serait ce que pour l'afficher, pourquoi ne pas le retourner ?

 ect...