00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 #ifndef ___HxCorbaSF_h__
00016 #define ___HxCorbaSF_h__
00017 
00018 #include <HxCorbaImageRep.h>
00019 
00020 #ifndef OB_INTEGER_VERSION
00021 #   error No ORBacus version defined! Is <OB/CORBA.h> included?
00022 #endif
00023 
00024 #ifndef OB_NO_VERSION_CHECK
00025 #   if (OB_INTEGER_VERSION != 4010000L)
00026 #       error ORBacus version mismatch!
00027 #   endif
00028 #endif
00029 
00030 namespace HxCorba
00031 {
00032 
00033 class SF;
00034 typedef SF* SF_ptr;
00035 typedef SF* SFRef;
00036 
00037 extern OB::TypeCodeConst _tc_SF;
00038 
00039 class SFFactory;
00040 typedef SFFactory* SFFactory_ptr;
00041 typedef SFFactory* SFFactoryRef;
00042 
00043 extern OB::TypeCodeConst _tc_SFFactory;
00044 
00045 } 
00046 
00047 void OBDuplicate(HxCorba::SF_ptr);
00048 void OBRelease(HxCorba::SF_ptr);
00049 
00050 void OBMarshal(HxCorba::SF_ptr, OB::OutputStreamImpl*);
00051 void OBUnmarshal(HxCorba::SF_ptr&, OB::InputStreamImpl*);
00052 
00053 void OBDuplicate(HxCorba::SFFactory_ptr);
00054 void OBRelease(HxCorba::SFFactory_ptr);
00055 
00056 void OBMarshal(HxCorba::SFFactory_ptr, OB::OutputStreamImpl*);
00057 void OBUnmarshal(HxCorba::SFFactory_ptr&, OB::InputStreamImpl*);
00058 
00059 namespace HxCorba
00060 {
00061 
00062 typedef OB::ObjVar< SF > SF_var;
00063 typedef OB::ObjOut< SF > SF_out;
00064 
00065 typedef OB::ObjVar< SFFactory > SFFactory_var;
00066 typedef OB::ObjOut< SFFactory > SFFactory_out;
00067 
00068 } 
00069 
00070 namespace OBStubImpl_HxCorba
00071 {
00072 
00073 class SF;
00074 typedef SF* SF_ptr;
00075 
00076 class SFFactory;
00077 typedef SFFactory* SFFactory_ptr;
00078 
00079 } 
00080 
00081 void OBDuplicate(OBStubImpl_HxCorba::SF_ptr);
00082 void OBRelease(OBStubImpl_HxCorba::SF_ptr);
00083 
00084 void OBDuplicate(OBStubImpl_HxCorba::SFFactory_ptr);
00085 void OBRelease(OBStubImpl_HxCorba::SFFactory_ptr);
00086 
00087 namespace OBStubImpl_HxCorba
00088 {
00089 
00090 typedef OB::ObjVar< SF > SF_var;
00091 
00092 typedef OB::ObjVar< SFFactory > SFFactory_var;
00093 
00094 } 
00095 
00096 
00097 
00098 
00099 namespace HxCorba
00100 {
00101 
00102 
00103 
00104 
00105 class SF : virtual public CORBA::Object
00106 {
00107     SF(const SF&);
00108     void operator=(const SF&);
00109 
00110 protected:
00111 
00112     static const char* ids_[];
00113 
00114 public:
00115 
00116     SF() { }
00117     virtual ~SF() { }
00118 
00119     typedef SF_ptr _ptr_type;
00120     typedef SF_var _var_type;
00121 
00122     static inline SF_ptr
00123     _duplicate(SF_ptr p)
00124     {
00125         if(p)
00126             p -> _add_ref();
00127         return p;
00128     }
00129 
00130     static inline SF_ptr
00131     _nil()
00132     {
00133         return 0;
00134     }
00135 
00136     static SF_ptr _narrow(CORBA::Object_ptr);
00137     static SF_ptr _unchecked_narrow(CORBA::Object_ptr);
00138 
00139     static SF_ptr _narrow(CORBA::AbstractBase_ptr);
00140     static SF_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00141 
00142     static const char** _OB_staticIds();
00143 
00144     
00145     
00146     
00147     virtual ImageRep_ptr getKernel() = 0;
00148 
00149     
00150     
00151     
00152     virtual ImageRep_ptr getHorizontalKernel() = 0;
00153 
00154     
00155     
00156     
00157     virtual ImageRep_ptr getVerticalKernel() = 0;
00158 
00159     
00160     
00161     
00162     virtual CORBA::Long isSeparable() = 0;
00163 
00164     
00165     
00166     
00167     virtual CORBA::Long isSymetric() = 0;
00168 
00169     
00170     
00171     
00172     virtual CORBA::Long getConnectivity() = 0;
00173 };
00174 
00175 
00176 
00177 
00178 class SFFactory : virtual public CORBA::Object
00179 {
00180     SFFactory(const SFFactory&);
00181     void operator=(const SFFactory&);
00182 
00183 protected:
00184 
00185     static const char* ids_[];
00186 
00187 public:
00188 
00189     SFFactory() { }
00190     virtual ~SFFactory() { }
00191 
00192     typedef SFFactory_ptr _ptr_type;
00193     typedef SFFactory_var _var_type;
00194 
00195     static inline SFFactory_ptr
00196     _duplicate(SFFactory_ptr p)
00197     {
00198         if(p)
00199             p -> _add_ref();
00200         return p;
00201     }
00202 
00203     static inline SFFactory_ptr
00204     _nil()
00205     {
00206         return 0;
00207     }
00208 
00209     static SFFactory_ptr _narrow(CORBA::Object_ptr);
00210     static SFFactory_ptr _unchecked_narrow(CORBA::Object_ptr);
00211 
00212     static SFFactory_ptr _narrow(CORBA::AbstractBase_ptr);
00213     static SFFactory_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00214 
00215     static const char** _OB_staticIds();
00216 
00217     
00218     
00219     
00220     virtual SF_ptr makeSFfromImage(ImageRep_ptr im) = 0;
00221 
00222     
00223     
00224     
00225     virtual SF_ptr makeFlatSF(ImageSignature sig,
00226                               const Sizes& sz,
00227                               const PixValue& val) = 0;
00228 
00229     
00230     
00231     
00232     virtual SF_ptr makeBoxSF(ImageSignature sig,
00233                              const Sizes& sz,
00234                              const PixValue& val) = 0;
00235 
00236     
00237     
00238     
00239     virtual SF_ptr makeCrossSF(ImageSignature sig,
00240                                const Sizes& sz,
00241                                const PixValue& val) = 0;
00242 
00243     
00244     
00245     
00246     virtual SF_ptr makeDiskSF(ImageSignature sig,
00247                               const Sizes& sz,
00248                               const PixValue& val) = 0;
00249 
00250     
00251     
00252     
00253     virtual SF_ptr makeDiamondSF(ImageSignature sig,
00254                                  const Sizes& sz,
00255                                  const PixValue& val) = 0;
00256 
00257     
00258     
00259     
00260     virtual SF_ptr makeGaussianSF(const Sizes& sz,
00261                                   CORBA::Double sigma) = 0;
00262 
00263     
00264     
00265     
00266     virtual SF_ptr makeParabolaSF(const Sizes& sz,
00267                                   CORBA::Double sigma) = 0;
00268 };
00269 
00270 } 
00271 
00272 
00273 
00274 
00275 namespace OBProxy_HxCorba
00276 {
00277 
00278 
00279 
00280 
00281 class SF : virtual public ::HxCorba::SF,
00282            virtual public OBCORBA::Object
00283 {
00284     SF(const SF&);
00285     void operator=(const SF&);
00286 
00287 protected:
00288 
00289     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00290 
00291 public:
00292 
00293     SF() { }
00294     virtual ~SF() { }
00295 
00296     virtual const char** _OB_ids() const;
00297 
00298     
00299     
00300     
00301     ::HxCorba::ImageRep_ptr getKernel();
00302 
00303     
00304     
00305     
00306     ::HxCorba::ImageRep_ptr getHorizontalKernel();
00307 
00308     
00309     
00310     
00311     ::HxCorba::ImageRep_ptr getVerticalKernel();
00312 
00313     
00314     
00315     
00316     CORBA::Long isSeparable();
00317 
00318     
00319     
00320     
00321     CORBA::Long isSymetric();
00322 
00323     
00324     
00325     
00326     CORBA::Long getConnectivity();
00327 };
00328 
00329 
00330 
00331 
00332 class SFFactory : virtual public ::HxCorba::SFFactory,
00333                   virtual public OBCORBA::Object
00334 {
00335     SFFactory(const SFFactory&);
00336     void operator=(const SFFactory&);
00337 
00338 protected:
00339 
00340     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00341 
00342 public:
00343 
00344     SFFactory() { }
00345     virtual ~SFFactory() { }
00346 
00347     virtual const char** _OB_ids() const;
00348 
00349     
00350     
00351     
00352     ::HxCorba::SF_ptr makeSFfromImage(::HxCorba::ImageRep_ptr im);
00353 
00354     
00355     
00356     
00357     ::HxCorba::SF_ptr makeFlatSF(::HxCorba::ImageSignature sig,
00358                                  const ::HxCorba::Sizes& sz,
00359                                  const ::HxCorba::PixValue& val);
00360 
00361     
00362     
00363     
00364     ::HxCorba::SF_ptr makeBoxSF(::HxCorba::ImageSignature sig,
00365                                 const ::HxCorba::Sizes& sz,
00366                                 const ::HxCorba::PixValue& val);
00367 
00368     
00369     
00370     
00371     ::HxCorba::SF_ptr makeCrossSF(::HxCorba::ImageSignature sig,
00372                                   const ::HxCorba::Sizes& sz,
00373                                   const ::HxCorba::PixValue& val);
00374 
00375     
00376     
00377     
00378     ::HxCorba::SF_ptr makeDiskSF(::HxCorba::ImageSignature sig,
00379                                  const ::HxCorba::Sizes& sz,
00380                                  const ::HxCorba::PixValue& val);
00381 
00382     
00383     
00384     
00385     ::HxCorba::SF_ptr makeDiamondSF(::HxCorba::ImageSignature sig,
00386                                     const ::HxCorba::Sizes& sz,
00387                                     const ::HxCorba::PixValue& val);
00388 
00389     
00390     
00391     
00392     ::HxCorba::SF_ptr makeGaussianSF(const ::HxCorba::Sizes& sz,
00393                                      CORBA::Double sigma);
00394 
00395     
00396     
00397     
00398     ::HxCorba::SF_ptr makeParabolaSF(const ::HxCorba::Sizes& sz,
00399                                      CORBA::Double sigma);
00400 };
00401 
00402 } 
00403 
00404 
00405 
00406 
00407 namespace OBStubImpl_HxCorba
00408 {
00409 
00410 
00411 
00412 
00413 class SF : virtual public OB::StubImplBase
00414 {
00415     SF(const SF&);
00416     void operator=(const SF&);
00417 
00418 protected:
00419 
00420     SF() { }
00421 
00422 public:
00423 
00424     static inline SF_ptr
00425     _duplicate(SF_ptr p)
00426     {
00427         if(p)
00428             p -> _OB_incRef();
00429         return p;
00430     }
00431 
00432     static inline SF_ptr
00433     _nil()
00434     {
00435         return 0;
00436     }
00437 
00438     
00439     
00440     
00441     virtual ::HxCorba::ImageRep_ptr getKernel() = 0;
00442 
00443     
00444     
00445     
00446     virtual ::HxCorba::ImageRep_ptr getHorizontalKernel() = 0;
00447 
00448     
00449     
00450     
00451     virtual ::HxCorba::ImageRep_ptr getVerticalKernel() = 0;
00452 
00453     
00454     
00455     
00456     virtual CORBA::Long isSeparable() = 0;
00457 
00458     
00459     
00460     
00461     virtual CORBA::Long isSymetric() = 0;
00462 
00463     
00464     
00465     
00466     virtual CORBA::Long getConnectivity() = 0;
00467 };
00468 
00469 
00470 
00471 
00472 class SFFactory : virtual public OB::StubImplBase
00473 {
00474     SFFactory(const SFFactory&);
00475     void operator=(const SFFactory&);
00476 
00477 protected:
00478 
00479     SFFactory() { }
00480 
00481 public:
00482 
00483     static inline SFFactory_ptr
00484     _duplicate(SFFactory_ptr p)
00485     {
00486         if(p)
00487             p -> _OB_incRef();
00488         return p;
00489     }
00490 
00491     static inline SFFactory_ptr
00492     _nil()
00493     {
00494         return 0;
00495     }
00496 
00497     
00498     
00499     
00500     virtual ::HxCorba::SF_ptr makeSFfromImage(::HxCorba::ImageRep_ptr im) = 0;
00501 
00502     
00503     
00504     
00505     virtual ::HxCorba::SF_ptr makeFlatSF(::HxCorba::ImageSignature sig,
00506                                          const ::HxCorba::Sizes& sz,
00507                                          const ::HxCorba::PixValue& val) = 0;
00508 
00509     
00510     
00511     
00512     virtual ::HxCorba::SF_ptr makeBoxSF(::HxCorba::ImageSignature sig,
00513                                         const ::HxCorba::Sizes& sz,
00514                                         const ::HxCorba::PixValue& val) = 0;
00515 
00516     
00517     
00518     
00519     virtual ::HxCorba::SF_ptr makeCrossSF(::HxCorba::ImageSignature sig,
00520                                           const ::HxCorba::Sizes& sz,
00521                                           const ::HxCorba::PixValue& val) = 0;
00522 
00523     
00524     
00525     
00526     virtual ::HxCorba::SF_ptr makeDiskSF(::HxCorba::ImageSignature sig,
00527                                          const ::HxCorba::Sizes& sz,
00528                                          const ::HxCorba::PixValue& val) = 0;
00529 
00530     
00531     
00532     
00533     virtual ::HxCorba::SF_ptr makeDiamondSF(::HxCorba::ImageSignature sig,
00534                                             const ::HxCorba::Sizes& sz,
00535                                             const ::HxCorba::PixValue& val) = 0;
00536 
00537     
00538     
00539     
00540     virtual ::HxCorba::SF_ptr makeGaussianSF(const ::HxCorba::Sizes& sz,
00541                                              CORBA::Double sigma) = 0;
00542 
00543     
00544     
00545     
00546     virtual ::HxCorba::SF_ptr makeParabolaSF(const ::HxCorba::Sizes& sz,
00547                                              CORBA::Double sigma) = 0;
00548 };
00549 
00550 } 
00551 
00552 
00553 
00554 
00555 namespace OBMarshalStubImpl_HxCorba
00556 {
00557 
00558 
00559 
00560 
00561 class SF : virtual public OBStubImpl_HxCorba::SF,
00562            virtual public OB::MarshalStubImpl
00563 {
00564     SF(const SF&);
00565     void operator=(const SF&);
00566 
00567 protected:
00568 
00569     SF() { }
00570     friend class OBProxy_HxCorba::SF;
00571 
00572 public:
00573 
00574     
00575     
00576     
00577     virtual ::HxCorba::ImageRep_ptr getKernel();
00578 
00579     
00580     
00581     
00582     virtual ::HxCorba::ImageRep_ptr getHorizontalKernel();
00583 
00584     
00585     
00586     
00587     virtual ::HxCorba::ImageRep_ptr getVerticalKernel();
00588 
00589     
00590     
00591     
00592     virtual CORBA::Long isSeparable();
00593 
00594     
00595     
00596     
00597     virtual CORBA::Long isSymetric();
00598 
00599     
00600     
00601     
00602     virtual CORBA::Long getConnectivity();
00603 };
00604 
00605 
00606 
00607 
00608 class SFFactory : virtual public OBStubImpl_HxCorba::SFFactory,
00609                   virtual public OB::MarshalStubImpl
00610 {
00611     SFFactory(const SFFactory&);
00612     void operator=(const SFFactory&);
00613 
00614 protected:
00615 
00616     SFFactory() { }
00617     friend class OBProxy_HxCorba::SFFactory;
00618 
00619 public:
00620 
00621     
00622     
00623     
00624     virtual ::HxCorba::SF_ptr makeSFfromImage(::HxCorba::ImageRep_ptr im);
00625 
00626     
00627     
00628     
00629     virtual ::HxCorba::SF_ptr makeFlatSF(::HxCorba::ImageSignature sig,
00630                                          const ::HxCorba::Sizes& sz,
00631                                          const ::HxCorba::PixValue& val);
00632 
00633     
00634     
00635     
00636     virtual ::HxCorba::SF_ptr makeBoxSF(::HxCorba::ImageSignature sig,
00637                                         const ::HxCorba::Sizes& sz,
00638                                         const ::HxCorba::PixValue& val);
00639 
00640     
00641     
00642     
00643     virtual ::HxCorba::SF_ptr makeCrossSF(::HxCorba::ImageSignature sig,
00644                                           const ::HxCorba::Sizes& sz,
00645                                           const ::HxCorba::PixValue& val);
00646 
00647     
00648     
00649     
00650     virtual ::HxCorba::SF_ptr makeDiskSF(::HxCorba::ImageSignature sig,
00651                                          const ::HxCorba::Sizes& sz,
00652                                          const ::HxCorba::PixValue& val);
00653 
00654     
00655     
00656     
00657     virtual ::HxCorba::SF_ptr makeDiamondSF(::HxCorba::ImageSignature sig,
00658                                             const ::HxCorba::Sizes& sz,
00659                                             const ::HxCorba::PixValue& val);
00660 
00661     
00662     
00663     
00664     virtual ::HxCorba::SF_ptr makeGaussianSF(const ::HxCorba::Sizes& sz,
00665                                              CORBA::Double sigma);
00666 
00667     
00668     
00669     
00670     virtual ::HxCorba::SF_ptr makeParabolaSF(const ::HxCorba::Sizes& sz,
00671                                              CORBA::Double sigma);
00672 };
00673 
00674 } 
00675 
00676 
00677 
00678 
00679 namespace OBV_HxCorba
00680 {
00681 
00682 } 
00683 
00684 
00685 
00686 
00687 namespace CORBA
00688 {
00689 
00690 inline void
00691 release(::HxCorba::SF_ptr p)
00692 {
00693     if(p)
00694         p -> _remove_ref();
00695 }
00696 
00697 inline Boolean
00698 is_nil(::HxCorba::SF_ptr p)
00699 {
00700     return p == 0;
00701 }
00702 
00703 inline void
00704 release(OBStubImpl_HxCorba::SF_ptr p)
00705 {
00706     if(p)
00707         p -> _OB_decRef();
00708 }
00709 
00710 inline Boolean
00711 is_nil(OBStubImpl_HxCorba::SF_ptr p)
00712 {
00713     return p == 0;
00714 }
00715 
00716 } 
00717 
00718 void operator<<=(CORBA::Any&, HxCorba::SF_ptr*);
00719 void operator<<=(CORBA::Any&, HxCorba::SF_ptr);
00720 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::SF_ptr&);
00721 
00722 inline void
00723 operator<<=(CORBA::Any_var& any, HxCorba::SF_ptr* val)
00724 {
00725     any.inout() <<= val;
00726 }
00727 
00728 inline void
00729 operator<<=(CORBA::Any_var& any, HxCorba::SF_ptr val)
00730 {
00731     any.inout() <<= val;
00732 }
00733 
00734 inline CORBA::Boolean
00735 operator>>=(const CORBA::Any_var& any, HxCorba::SF_ptr& val)
00736 {
00737     return any.in() >>= val;
00738 }
00739 
00740 
00741 
00742 
00743 namespace CORBA
00744 {
00745 
00746 inline void
00747 release(::HxCorba::SFFactory_ptr p)
00748 {
00749     if(p)
00750         p -> _remove_ref();
00751 }
00752 
00753 inline Boolean
00754 is_nil(::HxCorba::SFFactory_ptr p)
00755 {
00756     return p == 0;
00757 }
00758 
00759 inline void
00760 release(OBStubImpl_HxCorba::SFFactory_ptr p)
00761 {
00762     if(p)
00763         p -> _OB_decRef();
00764 }
00765 
00766 inline Boolean
00767 is_nil(OBStubImpl_HxCorba::SFFactory_ptr p)
00768 {
00769     return p == 0;
00770 }
00771 
00772 } 
00773 
00774 void operator<<=(CORBA::Any&, HxCorba::SFFactory_ptr*);
00775 void operator<<=(CORBA::Any&, HxCorba::SFFactory_ptr);
00776 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::SFFactory_ptr&);
00777 
00778 inline void
00779 operator<<=(CORBA::Any_var& any, HxCorba::SFFactory_ptr* val)
00780 {
00781     any.inout() <<= val;
00782 }
00783 
00784 inline void
00785 operator<<=(CORBA::Any_var& any, HxCorba::SFFactory_ptr val)
00786 {
00787     any.inout() <<= val;
00788 }
00789 
00790 inline CORBA::Boolean
00791 operator>>=(const CORBA::Any_var& any, HxCorba::SFFactory_ptr& val)
00792 {
00793     return any.in() >>= val;
00794 }
00795 
00796 #endif