---

HxCorbaHistogram.h

Go to the documentation of this file.

// **********************************************************************
//
// Generated by the ORBacus IDL-to-C++ Translator
//
// Copyright (c) 2000
// Object Oriented Concepts, Inc.
// Billerica, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

// Version: 4.0.5

#ifndef ___HxCorbaHistogram_h__
#define ___HxCorbaHistogram_h__

#include <HxCorbaImageRep.h>

#ifndef OB_INTEGER_VERSION
#   error No ORBacus version defined! Is <OB/CORBA.h> included?
#endif

#ifndef OB_NO_VERSION_CHECK
#   if (OB_INTEGER_VERSION != 4000500L)
#       error ORBacus version mismatch!
#   endif
#endif

namespace HxCorba
{

class HistogramData;
typedef HistogramData* HistogramData_ptr;
typedef HistogramData* HistogramDataRef;

extern OB::TypeCodeConst _tc_HistogramData;

class Histogram;
typedef Histogram* Histogram_ptr;
typedef Histogram* HistogramRef;

extern OB::TypeCodeConst _tc_Histogram;

class HistogramFactory;
typedef HistogramFactory* HistogramFactory_ptr;
typedef HistogramFactory* HistogramFactoryRef;

extern OB::TypeCodeConst _tc_HistogramFactory;

} // End of namespace HxCorba

void OBDuplicate(HxCorba::HistogramData_ptr);
void OBRelease(HxCorba::HistogramData_ptr);

void OBMarshal(HxCorba::HistogramData_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(HxCorba::HistogramData_ptr&, OB::InputStreamImpl*);

void OBDuplicate(HxCorba::Histogram_ptr);
void OBRelease(HxCorba::Histogram_ptr);

void OBMarshal(HxCorba::Histogram_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(HxCorba::Histogram_ptr&, OB::InputStreamImpl*);

void OBDuplicate(HxCorba::HistogramFactory_ptr);
void OBRelease(HxCorba::HistogramFactory_ptr);

void OBMarshal(HxCorba::HistogramFactory_ptr, OB::OutputStreamImpl*);
void OBUnmarshal(HxCorba::HistogramFactory_ptr&, OB::InputStreamImpl*);

namespace HxCorba
{

typedef OB::ObjVar< HistogramData > HistogramData_var;
typedef OB::ObjOut< HistogramData > HistogramData_out;

typedef OB::ObjVar< Histogram > Histogram_var;
typedef OB::ObjOut< Histogram > Histogram_out;

typedef OB::ObjVar< HistogramFactory > HistogramFactory_var;
typedef OB::ObjOut< HistogramFactory > HistogramFactory_out;

} // End of namespace HxCorba

namespace OBStubImpl_HxCorba
{

class HistogramData;
typedef HistogramData* HistogramData_ptr;

class Histogram;
typedef Histogram* Histogram_ptr;

class HistogramFactory;
typedef HistogramFactory* HistogramFactory_ptr;

} // End of namespace OBStubImpl_HxCorba

void OBDuplicate(OBStubImpl_HxCorba::HistogramData_ptr);
void OBRelease(OBStubImpl_HxCorba::HistogramData_ptr);

void OBDuplicate(OBStubImpl_HxCorba::Histogram_ptr);
void OBRelease(OBStubImpl_HxCorba::Histogram_ptr);

void OBDuplicate(OBStubImpl_HxCorba::HistogramFactory_ptr);
void OBRelease(OBStubImpl_HxCorba::HistogramFactory_ptr);

namespace OBStubImpl_HxCorba
{

typedef OB::ObjVar< HistogramData > HistogramData_var;

typedef OB::ObjVar< Histogram > Histogram_var;

typedef OB::ObjVar< HistogramFactory > HistogramFactory_var;

} // End of namespace OBStubImpl_HxCorba

//
// IDL:HxCorba:1.0
//
namespace HxCorba
{

//
// IDL:HxCorba/BinDataSequence:1.0
//
class OBUnique_BinDataSequence { };

typedef OB::FixSeq< CORBA::Double, OBUnique_BinDataSequence > BinDataSequence;
typedef OB::SeqVar< OB::FixSeq< CORBA::Double, OBUnique_BinDataSequence > > BinDataSequence_var;
typedef OB::SeqOut< OB::FixSeq< CORBA::Double, OBUnique_BinDataSequence > > BinDataSequence_out;
extern OB::TypeCodeConst _tc_BinDataSequence;

struct OBInfo_BinDataSequence : public OB::ConstructedInfo
{
    OBInfo_BinDataSequence() { }

    virtual void free(void* p) const
    {
        delete (BinDataSequence*)p;
    }

    virtual void* dup(const void* p) const
    {
        return new BinDataSequence(*(const BinDataSequence*)p);
    }

    virtual void marshal(const void*, OB::OutputStreamImpl*) const;
    virtual void unmarshal(void*, OB::InputStreamImpl*) const;
};

//
// IDL:HxCorba/HistogramData:1.0
//
class HistogramData : virtual public CORBA::Object
{
    HistogramData(const HistogramData&);
    void operator=(const HistogramData&);

    static const char* ids_[];

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    HistogramData() { }
    virtual ~HistogramData() { }

    typedef HistogramData_ptr _ptr_type;
    typedef HistogramData_var _var_type;

    static inline HistogramData_ptr
    _duplicate(HistogramData_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline HistogramData_ptr
    _nil()
    {
        return 0;
    }

    static HistogramData_ptr _narrow(CORBA::Object_ptr);
    static HistogramData_ptr _narrow(CORBA::AbstractBase_ptr);

    virtual const char** _OB_ids() const;
    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/HistogramData/dimensionality:1.0
    //
    CORBA::Long dimensionality();

    //
    // IDL:HxCorba/HistogramData/dimensionSize:1.0
    //
    CORBA::Long dimensionSize(CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/nrOfBins:1.0
    //
    CORBA::Long nrOfBins();

    //
    // IDL:HxCorba/HistogramData/lowBin:1.0
    //
    CORBA::Double lowBin(CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/highBin:1.0
    //
    CORBA::Double highBin(CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/binWidth:1.0
    //
    CORBA::Double binWidth(CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/binToValue:1.0
    //
    CORBA::Double binToValue(CORBA::Long bin,
                             CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/valueToBin:1.0
    //
    CORBA::Long valueToBin(CORBA::Double value,
                           CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/get1:1.0
    //
    CORBA::Double get1(CORBA::Long bin1);

    //
    // IDL:HxCorba/HistogramData/get2:1.0
    //
    CORBA::Double get2(CORBA::Long bin1,
                       CORBA::Long bin2);

    //
    // IDL:HxCorba/HistogramData/get3:1.0
    //
    CORBA::Double get3(CORBA::Long bin1,
                       CORBA::Long bin2,
                       CORBA::Long bin3);

    //
    // IDL:HxCorba/HistogramData/sum:1.0
    //
    CORBA::Double sum();

    //
    // IDL:HxCorba/HistogramData/minVal:1.0
    //
    CORBA::Double minVal();

    //
    // IDL:HxCorba/HistogramData/maxVal:1.0
    //
    CORBA::Double maxVal();

    //
    // IDL:HxCorba/HistogramData/maxValIndex:1.0
    //
    CORBA::Double maxValIndex(CORBA::Long_out index);

    //
    // IDL:HxCorba/HistogramData/getDataDouble:1.0
    //
    BinDataSequence* getDataDouble();
};

//
// IDL:HxCorba/HistogramMode:1.0
//
struct HistogramMode;
typedef OB::FixVar< HistogramMode > HistogramMode_var;
typedef HistogramMode& HistogramMode_out;

struct HistogramMode
{
    typedef HistogramMode_var _var_type;

    CORBA::Double x;
    CORBA::Double y;

    void _OB_marshal(OB::OutputStreamImpl*) const;
    static void _OB_unmarshal(HistogramMode&, OB::InputStreamImpl*);
};

extern OB::TypeCodeConst _tc_HistogramMode;

//
// IDL:HxCorba/HistogramModeSeq:1.0
//
class OBUnique_HistogramModeSeq { };

typedef OB::FixSeq< HistogramMode, OBUnique_HistogramModeSeq > HistogramModeSeq;
typedef OB::SeqVar< OB::FixSeq< HistogramMode, OBUnique_HistogramModeSeq > > HistogramModeSeq_var;
typedef OB::SeqOut< OB::FixSeq< HistogramMode, OBUnique_HistogramModeSeq > > HistogramModeSeq_out;
extern OB::TypeCodeConst _tc_HistogramModeSeq;

struct OBInfo_HistogramModeSeq : public OB::ConstructedInfo
{
    OBInfo_HistogramModeSeq() { }

    virtual void free(void* p) const
    {
        delete (HistogramModeSeq*)p;
    }

    virtual void* dup(const void* p) const
    {
        return new HistogramModeSeq(*(const HistogramModeSeq*)p);
    }

    virtual void marshal(const void*, OB::OutputStreamImpl*) const;
    virtual void unmarshal(void*, OB::InputStreamImpl*) const;
};

//
// IDL:HxCorba/Histogram:1.0
//
class Histogram : virtual public HxCorba::HistogramData
{
    Histogram(const Histogram&);
    void operator=(const Histogram&);

    static const char* ids_[];

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    Histogram() { }
    virtual ~Histogram() { }

    typedef Histogram_ptr _ptr_type;
    typedef Histogram_var _var_type;

    static inline Histogram_ptr
    _duplicate(Histogram_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline Histogram_ptr
    _nil()
    {
        return 0;
    }

    static Histogram_ptr _narrow(CORBA::Object_ptr);
    static Histogram_ptr _narrow(CORBA::AbstractBase_ptr);

    virtual const char** _OB_ids() const;
    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/Histogram/smooth:1.0
    //
    Histogram_ptr smooth(CORBA::Double sigma);

    //
    // IDL:HxCorba/Histogram/modes:1.0
    //
    HistogramModeSeq* modes();

    //
    // IDL:HxCorba/Histogram/normalize:1.0
    //
    Histogram_ptr normalize(CORBA::Double weight);

    //
    // IDL:HxCorba/Histogram/intersection:1.0
    //
    CORBA::Double intersection(Histogram_ptr h);

    //
    // IDL:HxCorba/Histogram/chiSquare:1.0
    //
    CORBA::Double chiSquare(Histogram_ptr h);

    //
    // IDL:HxCorba/Histogram/chiSquareNorm:1.0
    //
    CORBA::Double chiSquareNorm(Histogram_ptr h);

    //
    // IDL:HxCorba/Histogram/threshold:1.0
    //
    Histogram_ptr threshold(CORBA::Double valThreshold);

    //
    // IDL:HxCorba/Histogram/countBins:1.0
    //
    CORBA::Long countBins(CORBA::Double valThreshold);

    //
    // IDL:HxCorba/Histogram/reduceRange:1.0
    //
    Histogram_ptr reduceRange(CORBA::Long binMin1,
                              CORBA::Long binMax1,
                              CORBA::Long binMin2,
                              CORBA::Long binMax2,
                              CORBA::Long binMin3,
                              CORBA::Long binMax3);

    //
    // IDL:HxCorba/Histogram/reduceRangeVal:1.0
    //
    Histogram_ptr reduceRangeVal(CORBA::Double binValMin1,
                                 CORBA::Double binValMax1,
                                 CORBA::Double binValMin2,
                                 CORBA::Double binValMax2,
                                 CORBA::Double binValMin3,
                                 CORBA::Double binValMax3);

    //
    // IDL:HxCorba/Histogram/to1D:1.0
    //
    Histogram_ptr to1D(CORBA::Long dim);

    //
    // IDL:HxCorba/Histogram/render3d:1.0
    //
    void render3d(RgbBuffer_ptr buf,
                  CORBA::Long dataWidth,
                  CORBA::Long dataHeight,
                  CORBA::Double elevation,
                  CORBA::Double alpha,
                  CORBA::Double threshold);

    //
    // IDL:HxCorba/Histogram/destroy:1.0
    //
    void destroy();
};

//
// IDL:HxCorba/HistogramFactory:1.0
//
class HistogramFactory : virtual public CORBA::Object
{
    HistogramFactory(const HistogramFactory&);
    void operator=(const HistogramFactory&);

    static const char* ids_[];

protected:

    virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();

public:

    HistogramFactory() { }
    virtual ~HistogramFactory() { }

    typedef HistogramFactory_ptr _ptr_type;
    typedef HistogramFactory_var _var_type;

    static inline HistogramFactory_ptr
    _duplicate(HistogramFactory_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline HistogramFactory_ptr
    _nil()
    {
        return 0;
    }

    static HistogramFactory_ptr _narrow(CORBA::Object_ptr);
    static HistogramFactory_ptr _narrow(CORBA::AbstractBase_ptr);

    virtual const char** _OB_ids() const;
    static const char** _OB_staticIds();

    //
    // IDL:HxCorba/HistogramFactory/makeHistogramFromFile:1.0
    //
    Histogram_ptr makeHistogramFromFile(const char* filename);
};

//
// IDL:HxCorba/HistogramList:1.0
//
class OBUnique_HistogramList { };

typedef OB::ObjSeq< Histogram, OBUnique_HistogramList > HistogramList;
typedef OB::SeqVar< OB::ObjSeq< Histogram, OBUnique_HistogramList > > HistogramList_var;
typedef OB::SeqOut< OB::ObjSeq< Histogram, OBUnique_HistogramList > > HistogramList_out;
extern OB::TypeCodeConst _tc_HistogramList;

struct OBInfo_HistogramList : public OB::ConstructedInfo
{
    OBInfo_HistogramList() { }

    virtual void free(void* p) const
    {
        delete (HistogramList*)p;
    }

    virtual void* dup(const void* p) const
    {
        return new HistogramList(*(const HistogramList*)p);
    }

    virtual void marshal(const void*, OB::OutputStreamImpl*) const;
    virtual void unmarshal(void*, OB::InputStreamImpl*) const;
};

} // End of namespace HxCorba

//
// IDL:HxCorba:1.0
//
namespace OBStubImpl_HxCorba
{

//
// IDL:HxCorba/HistogramData:1.0
//
class HistogramData : virtual public OB::StubImplBase
{
    HistogramData(const HistogramData&);
    void operator=(const HistogramData&);

protected:

    HistogramData() { }

public:

    static inline HistogramData_ptr
    _duplicate(HistogramData_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline HistogramData_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/HistogramData/dimensionality:1.0
    //
    virtual CORBA::Long dimensionality() = 0;

    //
    // IDL:HxCorba/HistogramData/dimensionSize:1.0
    //
    virtual CORBA::Long dimensionSize(CORBA::Long dim) = 0;

    //
    // IDL:HxCorba/HistogramData/nrOfBins:1.0
    //
    virtual CORBA::Long nrOfBins() = 0;

    //
    // IDL:HxCorba/HistogramData/lowBin:1.0
    //
    virtual CORBA::Double lowBin(CORBA::Long dim) = 0;

    //
    // IDL:HxCorba/HistogramData/highBin:1.0
    //
    virtual CORBA::Double highBin(CORBA::Long dim) = 0;

    //
    // IDL:HxCorba/HistogramData/binWidth:1.0
    //
    virtual CORBA::Double binWidth(CORBA::Long dim) = 0;

    //
    // IDL:HxCorba/HistogramData/binToValue:1.0
    //
    virtual CORBA::Double binToValue(CORBA::Long bin,
                                     CORBA::Long dim) = 0;

    //
    // IDL:HxCorba/HistogramData/valueToBin:1.0
    //
    virtual CORBA::Long valueToBin(CORBA::Double value,
                                   CORBA::Long dim) = 0;

    //
    // IDL:HxCorba/HistogramData/get1:1.0
    //
    virtual CORBA::Double get1(CORBA::Long bin1) = 0;

    //
    // IDL:HxCorba/HistogramData/get2:1.0
    //
    virtual CORBA::Double get2(CORBA::Long bin1,
                               CORBA::Long bin2) = 0;

    //
    // IDL:HxCorba/HistogramData/get3:1.0
    //
    virtual CORBA::Double get3(CORBA::Long bin1,
                               CORBA::Long bin2,
                               CORBA::Long bin3) = 0;

    //
    // IDL:HxCorba/HistogramData/sum:1.0
    //
    virtual CORBA::Double sum() = 0;

    //
    // IDL:HxCorba/HistogramData/minVal:1.0
    //
    virtual CORBA::Double minVal() = 0;

    //
    // IDL:HxCorba/HistogramData/maxVal:1.0
    //
    virtual CORBA::Double maxVal() = 0;

    //
    // IDL:HxCorba/HistogramData/maxValIndex:1.0
    //
    virtual CORBA::Double maxValIndex(CORBA::Long_out index) = 0;

    //
    // IDL:HxCorba/HistogramData/getDataDouble:1.0
    //
    virtual HxCorba::BinDataSequence* getDataDouble() = 0;
};

//
// IDL:HxCorba/Histogram:1.0
//
class Histogram : virtual public OBStubImpl_HxCorba::HistogramData
{
    Histogram(const Histogram&);
    void operator=(const Histogram&);

protected:

    Histogram() { }

public:

    static inline Histogram_ptr
    _duplicate(Histogram_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline Histogram_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/Histogram/smooth:1.0
    //
    virtual HxCorba::Histogram_ptr smooth(CORBA::Double sigma) = 0;

    //
    // IDL:HxCorba/Histogram/modes:1.0
    //
    virtual HxCorba::HistogramModeSeq* modes() = 0;

    //
    // IDL:HxCorba/Histogram/normalize:1.0
    //
    virtual HxCorba::Histogram_ptr normalize(CORBA::Double weight) = 0;

    //
    // IDL:HxCorba/Histogram/intersection:1.0
    //
    virtual CORBA::Double intersection(HxCorba::Histogram_ptr h) = 0;

    //
    // IDL:HxCorba/Histogram/chiSquare:1.0
    //
    virtual CORBA::Double chiSquare(HxCorba::Histogram_ptr h) = 0;

    //
    // IDL:HxCorba/Histogram/chiSquareNorm:1.0
    //
    virtual CORBA::Double chiSquareNorm(HxCorba::Histogram_ptr h) = 0;

    //
    // IDL:HxCorba/Histogram/threshold:1.0
    //
    virtual HxCorba::Histogram_ptr threshold(CORBA::Double valThreshold) = 0;

    //
    // IDL:HxCorba/Histogram/countBins:1.0
    //
    virtual CORBA::Long countBins(CORBA::Double valThreshold) = 0;

    //
    // IDL:HxCorba/Histogram/reduceRange:1.0
    //
    virtual HxCorba::Histogram_ptr reduceRange(CORBA::Long binMin1,
                                               CORBA::Long binMax1,
                                               CORBA::Long binMin2,
                                               CORBA::Long binMax2,
                                               CORBA::Long binMin3,
                                               CORBA::Long binMax3) = 0;

    //
    // IDL:HxCorba/Histogram/reduceRangeVal:1.0
    //
    virtual HxCorba::Histogram_ptr reduceRangeVal(CORBA::Double binValMin1,
                                                  CORBA::Double binValMax1,
                                                  CORBA::Double binValMin2,
                                                  CORBA::Double binValMax2,
                                                  CORBA::Double binValMin3,
                                                  CORBA::Double binValMax3) = 0;

    //
    // IDL:HxCorba/Histogram/to1D:1.0
    //
    virtual HxCorba::Histogram_ptr to1D(CORBA::Long dim) = 0;

    //
    // IDL:HxCorba/Histogram/render3d:1.0
    //
    virtual void render3d(HxCorba::RgbBuffer_ptr buf,
                          CORBA::Long dataWidth,
                          CORBA::Long dataHeight,
                          CORBA::Double elevation,
                          CORBA::Double alpha,
                          CORBA::Double threshold) = 0;

    //
    // IDL:HxCorba/Histogram/destroy:1.0
    //
    virtual void destroy() = 0;
};

//
// IDL:HxCorba/HistogramFactory:1.0
//
class HistogramFactory : virtual public OB::StubImplBase
{
    HistogramFactory(const HistogramFactory&);
    void operator=(const HistogramFactory&);

protected:

    HistogramFactory() { }

public:

    static inline HistogramFactory_ptr
    _duplicate(HistogramFactory_ptr p)
    {
        if(p)
            p -> _OB_incRef();
        return p;
    }

    static inline HistogramFactory_ptr
    _nil()
    {
        return 0;
    }

    //
    // IDL:HxCorba/HistogramFactory/makeHistogramFromFile:1.0
    //
    virtual HxCorba::Histogram_ptr makeHistogramFromFile(const char* filename) = 0;
};

} // End of namespace OBStubImpl_HxCorba

//
// IDL:HxCorba:1.0
//
namespace OBMarshalStubImpl_HxCorba
{

//
// IDL:HxCorba/HistogramData:1.0
//
class HistogramData : virtual public OBStubImpl_HxCorba::HistogramData,
                      virtual public OB::MarshalStubImpl
{
    HistogramData(const HistogramData&);
    void operator=(const HistogramData&);

protected:

    HistogramData() { }
    friend class HxCorba::HistogramData;

public:

    //
    // IDL:HxCorba/HistogramData/dimensionality:1.0
    //
    virtual CORBA::Long dimensionality();

    //
    // IDL:HxCorba/HistogramData/dimensionSize:1.0
    //
    virtual CORBA::Long dimensionSize(CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/nrOfBins:1.0
    //
    virtual CORBA::Long nrOfBins();

    //
    // IDL:HxCorba/HistogramData/lowBin:1.0
    //
    virtual CORBA::Double lowBin(CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/highBin:1.0
    //
    virtual CORBA::Double highBin(CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/binWidth:1.0
    //
    virtual CORBA::Double binWidth(CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/binToValue:1.0
    //
    virtual CORBA::Double binToValue(CORBA::Long bin,
                                     CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/valueToBin:1.0
    //
    virtual CORBA::Long valueToBin(CORBA::Double value,
                                   CORBA::Long dim);

    //
    // IDL:HxCorba/HistogramData/get1:1.0
    //
    virtual CORBA::Double get1(CORBA::Long bin1);

    //
    // IDL:HxCorba/HistogramData/get2:1.0
    //
    virtual CORBA::Double get2(CORBA::Long bin1,
                               CORBA::Long bin2);

    //
    // IDL:HxCorba/HistogramData/get3:1.0
    //
    virtual CORBA::Double get3(CORBA::Long bin1,
                               CORBA::Long bin2,
                               CORBA::Long bin3);

    //
    // IDL:HxCorba/HistogramData/sum:1.0
    //
    virtual CORBA::Double sum();

    //
    // IDL:HxCorba/HistogramData/minVal:1.0
    //
    virtual CORBA::Double minVal();

    //
    // IDL:HxCorba/HistogramData/maxVal:1.0
    //
    virtual CORBA::Double maxVal();

    //
    // IDL:HxCorba/HistogramData/maxValIndex:1.0
    //
    virtual CORBA::Double maxValIndex(CORBA::Long_out index);

    //
    // IDL:HxCorba/HistogramData/getDataDouble:1.0
    //
    virtual HxCorba::BinDataSequence* getDataDouble();
};

//
// IDL:HxCorba/Histogram:1.0
//
class Histogram : virtual public OBStubImpl_HxCorba::Histogram,
                  virtual public OBMarshalStubImpl_HxCorba::HistogramData
{
    Histogram(const Histogram&);
    void operator=(const Histogram&);

protected:

    Histogram() { }
    friend class HxCorba::Histogram;

public:

    //
    // IDL:HxCorba/Histogram/smooth:1.0
    //
    virtual HxCorba::Histogram_ptr smooth(CORBA::Double sigma);

    //
    // IDL:HxCorba/Histogram/modes:1.0
    //
    virtual HxCorba::HistogramModeSeq* modes();

    //
    // IDL:HxCorba/Histogram/normalize:1.0
    //
    virtual HxCorba::Histogram_ptr normalize(CORBA::Double weight);

    //
    // IDL:HxCorba/Histogram/intersection:1.0
    //
    virtual CORBA::Double intersection(HxCorba::Histogram_ptr h);

    //
    // IDL:HxCorba/Histogram/chiSquare:1.0
    //
    virtual CORBA::Double chiSquare(HxCorba::Histogram_ptr h);

    //
    // IDL:HxCorba/Histogram/chiSquareNorm:1.0
    //
    virtual CORBA::Double chiSquareNorm(HxCorba::Histogram_ptr h);

    //
    // IDL:HxCorba/Histogram/threshold:1.0
    //
    virtual HxCorba::Histogram_ptr threshold(CORBA::Double valThreshold);

    //
    // IDL:HxCorba/Histogram/countBins:1.0
    //
    virtual CORBA::Long countBins(CORBA::Double valThreshold);

    //
    // IDL:HxCorba/Histogram/reduceRange:1.0
    //
    virtual HxCorba::Histogram_ptr reduceRange(CORBA::Long binMin1,
                                               CORBA::Long binMax1,
                                               CORBA::Long binMin2,
                                               CORBA::Long binMax2,
                                               CORBA::Long binMin3,
                                               CORBA::Long binMax3);

    //
    // IDL:HxCorba/Histogram/reduceRangeVal:1.0
    //
    virtual HxCorba::Histogram_ptr reduceRangeVal(CORBA::Double binValMin1,
                                                  CORBA::Double binValMax1,
                                                  CORBA::Double binValMin2,
                                                  CORBA::Double binValMax2,
                                                  CORBA::Double binValMin3,
                                                  CORBA::Double binValMax3);

    //
    // IDL:HxCorba/Histogram/to1D:1.0
    //
    virtual HxCorba::Histogram_ptr to1D(CORBA::Long dim);

    //
    // IDL:HxCorba/Histogram/render3d:1.0
    //
    virtual void render3d(HxCorba::RgbBuffer_ptr buf,
                          CORBA::Long dataWidth,
                          CORBA::Long dataHeight,
                          CORBA::Double elevation,
                          CORBA::Double alpha,
                          CORBA::Double threshold);

    //
    // IDL:HxCorba/Histogram/destroy:1.0
    //
    virtual void destroy();
};

//
// IDL:HxCorba/HistogramFactory:1.0
//
class HistogramFactory : virtual public OBStubImpl_HxCorba::HistogramFactory,
                         virtual public OB::MarshalStubImpl
{
    HistogramFactory(const HistogramFactory&);
    void operator=(const HistogramFactory&);

protected:

    HistogramFactory() { }
    friend class HxCorba::HistogramFactory;

public:

    //
    // IDL:HxCorba/HistogramFactory/makeHistogramFromFile:1.0
    //
    virtual HxCorba::Histogram_ptr makeHistogramFromFile(const char* filename);
};

} // End of namespace OBMarshalStubImpl_HxCorba

//
// IDL:HxCorba:1.0
//
namespace OBV_HxCorba
{

} // End of namespace OBV_HxCorba

//
// IDL:HxCorba/BinDataSequence:1.0
//
void operator<<=(CORBA::Any&, HxCorba::BinDataSequence*);
void operator<<=(CORBA::Any&, const HxCorba::BinDataSequence&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::BinDataSequence*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::BinDataSequence* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::BinDataSequence& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::BinDataSequence*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/HistogramData:1.0
//
namespace CORBA
{

inline void
release(HxCorba::HistogramData_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(HxCorba::HistogramData_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_HxCorba::HistogramData_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_HxCorba::HistogramData_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(CORBA::Any&, HxCorba::HistogramData_ptr*);
void operator<<=(CORBA::Any&, HxCorba::HistogramData_ptr);
CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::HistogramData_ptr&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::HistogramData_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, HxCorba::HistogramData_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, HxCorba::HistogramData_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/HistogramMode:1.0
//
void operator<<=(CORBA::Any&, HxCorba::HistogramMode*);
void operator<<=(CORBA::Any&, const HxCorba::HistogramMode&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::HistogramMode*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::HistogramMode* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::HistogramMode& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::HistogramMode*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/HistogramModeSeq:1.0
//
void operator<<=(CORBA::Any&, HxCorba::HistogramModeSeq*);
void operator<<=(CORBA::Any&, const HxCorba::HistogramModeSeq&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::HistogramModeSeq*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::HistogramModeSeq* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::HistogramModeSeq& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::HistogramModeSeq*& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/Histogram:1.0
//
namespace CORBA
{

inline void
release(HxCorba::Histogram_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(HxCorba::Histogram_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_HxCorba::Histogram_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_HxCorba::Histogram_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(CORBA::Any&, HxCorba::Histogram_ptr*);
void operator<<=(CORBA::Any&, HxCorba::Histogram_ptr);
CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::Histogram_ptr&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::Histogram_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, HxCorba::Histogram_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, HxCorba::Histogram_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/HistogramFactory:1.0
//
namespace CORBA
{

inline void
release(HxCorba::HistogramFactory_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(HxCorba::HistogramFactory_ptr p)
{
    return p == 0;
}

inline void
release(OBStubImpl_HxCorba::HistogramFactory_ptr p)
{
    if(p)
        p -> _OB_decRef();
}

inline Boolean
is_nil(OBStubImpl_HxCorba::HistogramFactory_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(CORBA::Any&, HxCorba::HistogramFactory_ptr*);
void operator<<=(CORBA::Any&, HxCorba::HistogramFactory_ptr);
CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::HistogramFactory_ptr&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::HistogramFactory_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, HxCorba::HistogramFactory_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, HxCorba::HistogramFactory_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:HxCorba/HistogramList:1.0
//
void operator<<=(CORBA::Any&, HxCorba::HistogramList*);
void operator<<=(CORBA::Any&, const HxCorba::HistogramList&);
CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::HistogramList*&);

inline void
operator<<=(CORBA::Any_var& any, HxCorba::HistogramList* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(CORBA::Any_var& any, const HxCorba::HistogramList& val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const CORBA::Any_var& any, const HxCorba::HistogramList*& val)
{
    return any.in() >>= val;
}

#endif

---