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