[C++] errore di compilazione (forse banale!!)

[marco.gheza]

ciao,
sto scrivendoun programma in C++ che realizzi una segmentazione di immagini mediche utilizzando la tecnica del watershed. Parto da un programma che mi è stato fornito che utilizza per leggere le immagini un costruttore chiamato Sgn3D_UI8. Il problema è che non compila; dà questo errore:

error C2679: '=' binario: non è stato trovato alcun operatore che accetti un operando destro di tipo 'int'. È anche possibile che non vi siano conversioni accettabili.

La parte interessata di codice è questa:


#include "stdWaterShed.h"

#include <time.h>

void WaterShed::transform(uint8& jump)
{
uint32 found, pos_fload, pos_neigh, start, end, inizio, fine; // INTERI SENZA SEGNO a 32 BIT
pt3d fictitious (3,0); // PUNTO 3D
pt3d vox, vox_floading;

uint32 curlab = WSHED+1;
pt3vect vect_found;

int32 lay_i, lay_j, lay_k;
lay_i = (int32)vol_layout_.numi();
lay_j = (int32)vol_layout_.numj();
lay_k = (int32)vol_layout_.numk();
//questo serve solo qui: è inutile vederlo all'esterno...
Sgn3D_UI8 vol_dist;

uint32 val_cornice = numi_*numj_*numk_ + WSHED;

vol_lab_.setnum(numi_+2*bordo, numj_+2*bordo, numk_+2*bordo);
vol_dist.setnum(numi_+2*bordo, numj_+2*bordo, numk_+2*bordo);

/*metto a zero tutto il volume dist e il bordo a 255*/
vol_dist.zero();
for(uint32 i = 0; i<vol_dist.numi(); i++)
{ for(uint32 j = 0; j<vol_dist.numj(); j++)
{for (uint32 k = 0; k<vol_dist.numk(); k++)
{if(i==0 || i==vol_dist.numi() || j==0 || j==vol_dist.numj() || k==0 || k==vol_dist.numk() ) vol_dist(i,j,k)==255;
//else vol_dist(i,j,k) = 0;
}
}
}
uint8 *d_dist(vol_dist.ptr());

/*metto a INIT tutto il volume LAB con il bordo a val_cornice*/
vol_lab_ = INIT;



l'errore è sull'ultima riga.

Se qualcuno mi salva, grazie mille.
ciao a tutti!!
Marco

[Teo@Unix]

Se non sbaglio "vol_lab_" è una classe (o struttura?, ho detto classe perchè hai messo C++), pertanto avrà definito un overload dell'operatore "=".
Quindi a destra dell'operatore va messo un oggetto di tipo "vol_lab_".


/*metto a INIT tutto il volume LAB con il bordo a val_cornice*/


mentre INIT che tipo di elemento è?

[cionci]

MA la riga in cui hai l'errore qual è ?

[marco.gheza]

la riga dell'errore è l'ultima. INIT è di tipo uint32 ma dà lo stesso problema anche con un intero.
Inserisco anche l'header dove è definito vol_lab_




#include "Sgn3D.h"

class WaterShed:public SgnCoord
{
public:

WaterShed(const Sgn3D_UI8& volume):numi_(volume.numi()), numj_(volume.numj()), numk_(volume.numk())
{ bordo =1;
INQUEUE = 0;
MASK = 1;
INIT = 2;
WSHED = 3;
vol_layout_.setnum(volume.numi()+2*bordo, volume.numj()+2*bordo, volume.numk()+2*bordo);
incornicia(volume, bordo,vol_layout_);
bucketsort(vol_layout_);
}

num_type numi() const { return numi_; }
num_type numj() const { return numj_; }
num_type numk() const { return numk_; }
uint8 h_max() const { return h_max_; }
uint8 h_min() const { return h_min_; }

const Sgn3D_UI8& vol_layout() const { return vol_layout_; }
const Sgn3D_UI32& vol_labelled() const { return vol_labelled_; }

void set_h_max(uint8& value){ h_max_= value;}
void set_h_min(uint8& value){ h_min_= value;}


void ws_exe(Sgn3D_UI8& vol_dest, uint8& jump, const uint8& good, const uint8& bad, bool label);
void transform(uint8& jump);
void result(const Sgn3D_UI32& vol_in, Sgn3D_UI8& vol_out, uint32& wshed,const uint8& good, const uint8& bad);
void incornicia(const Sgn3D_UI8& vol_in, uint8& bordo, Sgn3D_UI8& vol_out);
void extract(const Sgn3D_UI32& vol_in, Sgn3D_UI32& vol_out );
void bucketsort(Sgn3D_UI8& volume);


private:
uint32 WSHED, INQUEUE, MASK, INIT;
uint8 h_min_, h_max_, bordo;
num_type numi_, numj_, numk_;
Sgn3D_UI32 vol_lab_, vol_labelled_;
Sgn3D_UI8 vol_layout_;
pt3vect vect_vol;
std::vector<uint32> vect_hist;
};

[cionci]

E Sgn3D_UI32 dov'è definito ?

[marco.gheza]

è una classe definita così:

template <class T>
class Sgn3D:public Sgn_base<T>
{ public:

typedef Sgn_base<T>::num_type num_type;
typedef Sgn_base<T>::rcdata_type rcdata_type;
// typedef Sgn_base<T>::stat_type stat_type;

Sgn3D():Sgn_base<T>(0),numi_(0),numj_(0),numk_(0),numij_(0),dx_(1.),dy_(1.),dz_(1.){}
Sgn3D(num_type numi,num_type numj,num_type numk,float64 dx=1.,float64 dy=1.,float64 dz=1.):
Sgn_base<T>(numi*numj*numk),numi_(numi),numj_(numj),numk_(numk),numij_(numi*numj),
dx_(dx),dy_(dy),dz_(dz)
{ assert(dx>=std::numeric_limits<float64>::epsilon());
assert(dy>=std::numeric_limits<float64>::epsilon());
assert(dz>=std::numeric_limits<float64>::epsilon());
}
// const Sgn3D &operator=(T val) { static_cast<Sgn_base<T> >(*this) = val; }
//** costr copia e op= templated per altri tipi
void ref(Sgn3D<T>& isgn);
void raw_load( std::istream &istr ) { Sgn3D<T>::raw_load(istr); }
void raw_load( num_type numi, num_type numj,num_type numk, std::istream &istr );
void setnum( num_type new_numi, num_type new_numj, num_type new_numk );
void gridlen( float64 dx, float64 dy, float64 dz );
template <class T1> void setnum(const Sgn3D<T1>& isgn);
void setnum(const BinSgn3D& isgn );
template <class T1> void setdim(const Sgn3D<T1>& isgn); //numero campioni + lunghezze
void setdim(const BinSgn3D& isgn );
const T& operator()( num_type i, num_type j, num_type k ) const
{ assert( i<numi_ && j<numj_ && k<numk_ );
return data_[i+numi_*j+numij_*k];
}
T& operator()( num_type i, num_type j, num_type k )
{ assert( i<numi_ && j<numj_ && k<numk_ );
return data_[i+numi_*j+numij_*k];
}
float64 dx() const { return dx_; }
float64 dy() const { return dy_; }
float64 dz() const { return dz_; }
float64 dxyz() const { return dx_*dy_*dz_; }
num_type numi() const { return numi_; }
num_type numj() const { return numj_; }
num_type numk() const { return numk_; }
void numijk(num_type &ni,num_type &nj,num_type &nk) const { ni=numi_; nj=numj_; nk=numk_; }
void lenxyz( float64& dx, float64& dy, float64& dz ) const { dx=dx_; dy=dy_; dz=dz_; }
template <class T1> bool samenum(const Sgn3D<T1>& isgn) const;
template <class T1> bool samelen(const Sgn3D<T1>& isgn) const;
//** idem bin...
void ISlice( num_type ic, Sgn2D<T> &islice ) const;
void JSlice( num_type jc, Sgn2D<T> &jslice ) const;
void KSlice( num_type kc, Sgn2D<T> &kslice ) const;
const Sgn2D<T> ISlice( num_type ic ) const;
const Sgn2D<T> JSlice( num_type jc ) const;
const Sgn2D<T> KSlice( num_type kc ) const;
private:
num_type numi_, numj_, numk_, numij_;
float64 dx_,dy_,dz_;
};

[cionci]

Sgn3D_UI32 probabilmente è un typedef con il tipo del template a uint32, verifica un attimo.

[lupoxxx87]

ma solo a me hanno insegnato che nei file di header è meglio mettere solo i prototipi di funzione ?

[cionci]

ma solo a me hanno insegnato che nei file di header è meglio mettere solo i prototipi di funzione ?
Con i template sei obbligato a mettere anche l'implementazione.

[lupoxxx87]

Con i template sei obbligato a mettere anche l'implementazione.

ok ok....
ma solo perchè sei juventino, hai una bella moto e una bella chitarra xD

[Prince_81]

Con i template sei obbligato a mettere anche l'implementazione.

cionci durante la creazione di un progetto ho scoperto che hai ragione, purtroppo quando si lavora con i template non è possibile suddividere la definizione della classe dalla sua implementazione a meno che non si adottino le seguenti soluzioni che sono due:
1) explicit template instantiation
2) l'utilizzo di export

in entrambi i casi ci sono dei problemi, nel primo si perde quasi la generalizzazione della classe, nel secondo caso la parola chiave non è supportata da molti compilatori.

A questo punto volevo chiederti, mettere sia la definizione che l'implementazione della classe nel file header è un errore in ambito professionale? cioè potrebbe essere considerata una boiata dagli esperti?

[banryu79]

A questo punto volevo chiederti, mettere sia la definizione che l'implementazione della classe nel file header è un errore in ambito professionale? cioè potrebbe essere considerata una boiata dagli esperti?
Difficile che cionci ti risponda: il thread è di due anni fa, e l'ultimo suo post visibile è del 03-07-2011.

[Prince_81]

:eek: speriamo non abbia abbandonato il forum !!!!