[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]

Originariamente inviato da lupoxxx87

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]

Originariamente inviato da cionci

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]

Originariamente inviato da cionci

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]

Originariamente inviato da Prince_81

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]

speriamo non abbia abbandonato il forum !!!!