00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 #ifndef ___HxCorbaGlobalOps_h__
00016 #define ___HxCorbaGlobalOps_h__
00017 
00018 #include <HxCorbaUserOps.h>
00019 #include <HxCorbaSF.h>
00020 #include <HxCorbaHistogram.h>
00021 #include <HxCorbaNJet.h>
00022 #include <HxCorbaBlob2d.h>
00023 
00024 #ifndef OB_INTEGER_VERSION
00025 #   error No ORBacus version defined! Is <OB/CORBA.h> included?
00026 #endif
00027 
00028 #ifndef OB_NO_VERSION_CHECK
00029 #   if (OB_INTEGER_VERSION != 4010000L)
00030 #       error ORBacus version mismatch!
00031 #   endif
00032 #endif
00033 
00034 namespace HxCorba
00035 {
00036 
00037 class GlobalOps;
00038 typedef GlobalOps* GlobalOps_ptr;
00039 typedef GlobalOps* GlobalOpsRef;
00040 
00041 extern OB::TypeCodeConst _tc_GlobalOps;
00042 
00043 } 
00044 
00045 void OBDuplicate(HxCorba::GlobalOps_ptr);
00046 void OBRelease(HxCorba::GlobalOps_ptr);
00047 
00048 void OBMarshal(HxCorba::GlobalOps_ptr, OB::OutputStreamImpl*);
00049 void OBUnmarshal(HxCorba::GlobalOps_ptr&, OB::InputStreamImpl*);
00050 
00051 namespace HxCorba
00052 {
00053 
00054 typedef OB::ObjVar< GlobalOps > GlobalOps_var;
00055 typedef OB::ObjOut< GlobalOps > GlobalOps_out;
00056 
00057 } 
00058 
00059 namespace OBStubImpl_HxCorba
00060 {
00061 
00062 class GlobalOps;
00063 typedef GlobalOps* GlobalOps_ptr;
00064 
00065 } 
00066 
00067 void OBDuplicate(OBStubImpl_HxCorba::GlobalOps_ptr);
00068 void OBRelease(OBStubImpl_HxCorba::GlobalOps_ptr);
00069 
00070 namespace OBStubImpl_HxCorba
00071 {
00072 
00073 typedef OB::ObjVar< GlobalOps > GlobalOps_var;
00074 
00075 } 
00076 
00077 
00078 
00079 
00080 namespace HxCorba
00081 {
00082 
00083 
00084 
00085 
00086 enum ColorModel
00087 {
00088     RGB,
00089     CMY,
00090     XYZ,
00091     Lab,
00092     Luv,
00093     OOO,
00094     HSI
00095 };
00096 
00097 typedef ColorModel& ColorModel_out;
00098 
00099 extern OB::TypeCodeConst _tc_ColorModel;
00100 
00101 
00102 
00103 
00104 enum ColorGaborSegmentationInvariant
00105 {
00106     E,
00107     W,
00108     C,
00109     Ci
00110 };
00111 
00112 typedef ColorGaborSegmentationInvariant& ColorGaborSegmentationInvariant_out;
00113 
00114 extern OB::TypeCodeConst _tc_ColorGaborSegmentationInvariant;
00115 
00116 
00117 
00118 
00119 enum ColorGaborSegmentationAlgorithm
00120 {
00121     Texture,
00122     TextureAddZero,
00123     OnlyZero
00124 };
00125 
00126 typedef ColorGaborSegmentationAlgorithm& ColorGaborSegmentationAlgorithm_out;
00127 
00128 extern OB::TypeCodeConst _tc_ColorGaborSegmentationAlgorithm;
00129 
00130 
00131 
00132 
00133 class GlobalOps : virtual public ::HxCorba::UserOps
00134 {
00135     GlobalOps(const GlobalOps&);
00136     void operator=(const GlobalOps&);
00137 
00138 protected:
00139 
00140     static const char* ids_[];
00141 
00142 public:
00143 
00144     GlobalOps() { }
00145     virtual ~GlobalOps() { }
00146 
00147     typedef GlobalOps_ptr _ptr_type;
00148     typedef GlobalOps_var _var_type;
00149 
00150     static inline GlobalOps_ptr
00151     _duplicate(GlobalOps_ptr p)
00152     {
00153         if(p)
00154             p -> _add_ref();
00155         return p;
00156     }
00157 
00158     static inline GlobalOps_ptr
00159     _nil()
00160     {
00161         return 0;
00162     }
00163 
00164     static GlobalOps_ptr _narrow(CORBA::Object_ptr);
00165     static GlobalOps_ptr _unchecked_narrow(CORBA::Object_ptr);
00166 
00167     static GlobalOps_ptr _narrow(CORBA::AbstractBase_ptr);
00168     static GlobalOps_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00169 
00170     static const char** _OB_staticIds();
00171 
00172     
00173     
00174     
00175     virtual ImageRep_ptr HxAbs(ImageRep_ptr im) = 0;
00176 
00177     
00178     
00179     
00180     virtual ImageRep_ptr HxCeil(ImageRep_ptr im) = 0;
00181 
00182     
00183     
00184     
00185     virtual ImageRep_ptr HxComplement(ImageRep_ptr im) = 0;
00186 
00187     
00188     
00189     
00190     virtual ImageRep_ptr HxExp(ImageRep_ptr im) = 0;
00191 
00192     
00193     
00194     
00195     virtual ImageRep_ptr HxFloor(ImageRep_ptr im) = 0;
00196 
00197     
00198     
00199     
00200     virtual ImageRep_ptr HxLog(ImageRep_ptr im) = 0;
00201 
00202     
00203     
00204     
00205     virtual ImageRep_ptr HxLog10(ImageRep_ptr im) = 0;
00206 
00207     
00208     
00209     
00210     virtual ImageRep_ptr HxNegate(ImageRep_ptr im) = 0;
00211 
00212     
00213     
00214     
00215     virtual ImageRep_ptr HxNorm1(ImageRep_ptr im) = 0;
00216 
00217     
00218     
00219     
00220     virtual ImageRep_ptr HxNorm2(ImageRep_ptr im) = 0;
00221 
00222     
00223     
00224     
00225     virtual ImageRep_ptr HxNormInf(ImageRep_ptr im) = 0;
00226 
00227     
00228     
00229     
00230     virtual ImageRep_ptr HxProjectRange(ImageRep_ptr im,
00231                                         CORBA::Long dimension) = 0;
00232 
00233     
00234     
00235     
00236     virtual ImageRep_ptr HxReciprocal(ImageRep_ptr im) = 0;
00237 
00238     
00239     
00240     
00241     virtual ImageRep_ptr HxSqrt(ImageRep_ptr im) = 0;
00242 
00243     
00244     
00245     
00246     virtual ImageRep_ptr HxRound(ImageRep_ptr im) = 0;
00247 
00248     
00249     
00250     
00251     virtual ImageRep_ptr HxUnaryMax(ImageRep_ptr im) = 0;
00252 
00253     
00254     
00255     
00256     virtual ImageRep_ptr HxUnaryMin(ImageRep_ptr im) = 0;
00257 
00258     
00259     
00260     
00261     virtual ImageRep_ptr HxUnaryProduct(ImageRep_ptr im) = 0;
00262 
00263     
00264     
00265     
00266     virtual ImageRep_ptr HxUnarySum(ImageRep_ptr im) = 0;
00267 
00268     
00269     
00270     
00271     virtual ImageRep_ptr HxAcos(ImageRep_ptr im) = 0;
00272 
00273     
00274     
00275     
00276     virtual ImageRep_ptr HxAsin(ImageRep_ptr im) = 0;
00277 
00278     
00279     
00280     
00281     virtual ImageRep_ptr HxAtan(ImageRep_ptr im) = 0;
00282 
00283     
00284     
00285     
00286     virtual ImageRep_ptr HxAtan2(ImageRep_ptr im) = 0;
00287 
00288     
00289     
00290     
00291     virtual ImageRep_ptr HxCos(ImageRep_ptr im) = 0;
00292 
00293     
00294     
00295     
00296     virtual ImageRep_ptr HxCosh(ImageRep_ptr im) = 0;
00297 
00298     
00299     
00300     
00301     virtual ImageRep_ptr HxSin(ImageRep_ptr im) = 0;
00302 
00303     
00304     
00305     
00306     virtual ImageRep_ptr HxSinh(ImageRep_ptr im) = 0;
00307 
00308     
00309     
00310     
00311     virtual ImageRep_ptr HxTan(ImageRep_ptr im) = 0;
00312 
00313     
00314     
00315     
00316     virtual ImageRep_ptr HxTanh(ImageRep_ptr im) = 0;
00317 
00318     
00319     
00320     
00321     virtual ImageRep_ptr HxArg(ImageRep_ptr im) = 0;
00322 
00323     
00324     
00325     
00326     virtual ImageRep_ptr HxConjugate(ImageRep_ptr im) = 0;
00327 
00328     
00329     
00330     
00331     virtual ImageRep_ptr HxAdd(ImageRep_ptr im1,
00332                                ImageRep_ptr im2) = 0;
00333 
00334     
00335     
00336     
00337     virtual ImageRep_ptr HxAddSat(ImageRep_ptr im1,
00338                                   ImageRep_ptr im2) = 0;
00339 
00340     
00341     
00342     
00343     virtual ImageRep_ptr HxAnd(ImageRep_ptr im1,
00344                                ImageRep_ptr im2) = 0;
00345 
00346     
00347     
00348     
00349     virtual ImageRep_ptr HxCross(ImageRep_ptr im1,
00350                                  ImageRep_ptr im2) = 0;
00351 
00352     
00353     
00354     
00355     virtual ImageRep_ptr HxDiv(ImageRep_ptr im1,
00356                                ImageRep_ptr im2) = 0;
00357 
00358     
00359     
00360     
00361     virtual ImageRep_ptr HxDot(ImageRep_ptr im1,
00362                                ImageRep_ptr im2) = 0;
00363 
00364     
00365     
00366     
00367     virtual ImageRep_ptr HxEqual(ImageRep_ptr im1,
00368                                  ImageRep_ptr im2) = 0;
00369 
00370     
00371     
00372     
00373     virtual ImageRep_ptr HxGreaterEqual(ImageRep_ptr im1,
00374                                         ImageRep_ptr im2) = 0;
00375 
00376     
00377     
00378     
00379     virtual ImageRep_ptr HxGreaterThan(ImageRep_ptr im1,
00380                                        ImageRep_ptr im2) = 0;
00381 
00382     
00383     
00384     
00385     virtual ImageRep_ptr HxInf(ImageRep_ptr im1,
00386                                ImageRep_ptr im2) = 0;
00387 
00388     
00389     
00390     
00391     virtual ImageRep_ptr HxInverseProjectRange(ImageRep_ptr im1,
00392                                                CORBA::Long dimension,
00393                                                ImageRep_ptr im2) = 0;
00394 
00395     
00396     
00397     
00398     virtual ImageRep_ptr HxLeftShift(ImageRep_ptr im1,
00399                                      ImageRep_ptr im2) = 0;
00400 
00401     
00402     
00403     
00404     virtual ImageRep_ptr HxLessEqual(ImageRep_ptr im1,
00405                                      ImageRep_ptr im2) = 0;
00406 
00407     
00408     
00409     
00410     virtual ImageRep_ptr HxLessThan(ImageRep_ptr im1,
00411                                     ImageRep_ptr im2) = 0;
00412 
00413     
00414     
00415     
00416     virtual ImageRep_ptr HxMax(ImageRep_ptr im1,
00417                                ImageRep_ptr im2) = 0;
00418 
00419     
00420     
00421     
00422     virtual ImageRep_ptr HxMin(ImageRep_ptr im1,
00423                                ImageRep_ptr im2) = 0;
00424 
00425     
00426     
00427     
00428     virtual ImageRep_ptr HxMod(ImageRep_ptr im1,
00429                                ImageRep_ptr im2) = 0;
00430 
00431     
00432     
00433     
00434     virtual ImageRep_ptr HxMul(ImageRep_ptr im1,
00435                                ImageRep_ptr im2) = 0;
00436 
00437     
00438     
00439     
00440     virtual ImageRep_ptr HxNotEqual(ImageRep_ptr im1,
00441                                     ImageRep_ptr im2) = 0;
00442 
00443     
00444     
00445     
00446     virtual ImageRep_ptr HxOr(ImageRep_ptr im1,
00447                               ImageRep_ptr im2) = 0;
00448 
00449     
00450     
00451     
00452     virtual ImageRep_ptr HxPow(ImageRep_ptr im1,
00453                                ImageRep_ptr im2) = 0;
00454 
00455     
00456     
00457     
00458     virtual ImageRep_ptr HxRightShift(ImageRep_ptr im1,
00459                                       ImageRep_ptr im2) = 0;
00460 
00461     
00462     
00463     
00464     virtual ImageRep_ptr HxSub(ImageRep_ptr im1,
00465                                ImageRep_ptr im2) = 0;
00466 
00467     
00468     
00469     
00470     virtual ImageRep_ptr HxSubSat(ImageRep_ptr im1,
00471                                   ImageRep_ptr im2) = 0;
00472 
00473     
00474     
00475     
00476     virtual ImageRep_ptr HxSup(ImageRep_ptr im1,
00477                                ImageRep_ptr im2) = 0;
00478 
00479     
00480     
00481     
00482     virtual ImageRep_ptr HxXor(ImageRep_ptr im1,
00483                                ImageRep_ptr im2) = 0;
00484 
00485     
00486     
00487     
00488     virtual ImageRep_ptr HxAddVal(ImageRep_ptr im,
00489                                   const PixValue& val) = 0;
00490 
00491     
00492     
00493     
00494     virtual ImageRep_ptr HxAndVal(ImageRep_ptr im,
00495                                   const PixValue& val) = 0;
00496 
00497     
00498     
00499     
00500     virtual ImageRep_ptr HxCrossVal(ImageRep_ptr im,
00501                                     const PixValue& val) = 0;
00502 
00503     
00504     
00505     
00506     virtual ImageRep_ptr HxDivVal(ImageRep_ptr im,
00507                                   const PixValue& val) = 0;
00508 
00509     
00510     
00511     
00512     virtual ImageRep_ptr HxDotVal(ImageRep_ptr im,
00513                                   const PixValue& val) = 0;
00514 
00515     
00516     
00517     
00518     virtual ImageRep_ptr HxEqualVal(ImageRep_ptr im,
00519                                     const PixValue& val) = 0;
00520 
00521     
00522     
00523     
00524     virtual ImageRep_ptr HxGreaterEqualVal(ImageRep_ptr im,
00525                                            const PixValue& val) = 0;
00526 
00527     
00528     
00529     
00530     virtual ImageRep_ptr HxGreaterThanVal(ImageRep_ptr im,
00531                                           const PixValue& val) = 0;
00532 
00533     
00534     
00535     
00536     virtual ImageRep_ptr HxInfVal(ImageRep_ptr im,
00537                                   const PixValue& val) = 0;
00538 
00539     
00540     
00541     
00542     virtual ImageRep_ptr HxLeftShiftVal(ImageRep_ptr im,
00543                                         const PixValue& val) = 0;
00544 
00545     
00546     
00547     
00548     virtual ImageRep_ptr HxLessEqualVal(ImageRep_ptr im,
00549                                         const PixValue& val) = 0;
00550 
00551     
00552     
00553     
00554     virtual ImageRep_ptr HxLessThanVal(ImageRep_ptr im,
00555                                        const PixValue& val) = 0;
00556 
00557     
00558     
00559     
00560     virtual ImageRep_ptr HxMaxVal(ImageRep_ptr im,
00561                                   const PixValue& val) = 0;
00562 
00563     
00564     
00565     
00566     virtual ImageRep_ptr HxMinVal(ImageRep_ptr im,
00567                                   const PixValue& val) = 0;
00568 
00569     
00570     
00571     
00572     virtual ImageRep_ptr HxModVal(ImageRep_ptr im,
00573                                   const PixValue& val) = 0;
00574 
00575     
00576     
00577     
00578     virtual ImageRep_ptr HxMulVal(ImageRep_ptr im,
00579                                   const PixValue& val) = 0;
00580 
00581     
00582     
00583     
00584     virtual ImageRep_ptr HxNotEqualVal(ImageRep_ptr im,
00585                                        const PixValue& val) = 0;
00586 
00587     
00588     
00589     
00590     virtual ImageRep_ptr HxOrVal(ImageRep_ptr im,
00591                                  const PixValue& val) = 0;
00592 
00593     
00594     
00595     
00596     virtual ImageRep_ptr HxPowVal(ImageRep_ptr im,
00597                                   const PixValue& val) = 0;
00598 
00599     
00600     
00601     
00602     virtual ImageRep_ptr HxRightShiftVal(ImageRep_ptr im,
00603                                          const PixValue& val) = 0;
00604 
00605     
00606     
00607     
00608     virtual ImageRep_ptr HxSubVal(ImageRep_ptr im,
00609                                   const PixValue& val) = 0;
00610 
00611     
00612     
00613     
00614     virtual ImageRep_ptr HxSupVal(ImageRep_ptr im,
00615                                   const PixValue& val) = 0;
00616 
00617     
00618     
00619     
00620     virtual ImageRep_ptr HxXorVal(ImageRep_ptr im,
00621                                   const PixValue& val) = 0;
00622 
00623     
00624     
00625     
00626     virtual PixValue HxPixInf(ImageRep_ptr im) = 0;
00627 
00628     
00629     
00630     
00631     virtual PixValue HxPixMax(ImageRep_ptr im) = 0;
00632 
00633     
00634     
00635     
00636     virtual PixValue HxPixMin(ImageRep_ptr im) = 0;
00637 
00638     
00639     
00640     
00641     virtual PixValue HxPixProduct(ImageRep_ptr im) = 0;
00642 
00643     
00644     
00645     
00646     virtual PixValue HxPixSum(ImageRep_ptr im) = 0;
00647 
00648     
00649     
00650     
00651     virtual PixValue HxPixSup(ImageRep_ptr im) = 0;
00652 
00653     
00654     
00655     
00656     virtual ImageRep_ptr HxImageAsByte(ImageRep_ptr img) = 0;
00657 
00658     
00659     
00660     
00661     virtual ImageRep_ptr HxImageAsDouble(ImageRep_ptr img) = 0;
00662 
00663     
00664     
00665     
00666     virtual ImageRep_ptr HxImageAsFloat(ImageRep_ptr img) = 0;
00667 
00668     
00669     
00670     
00671     virtual ImageRep_ptr HxImageAsShort(ImageRep_ptr img) = 0;
00672 
00673     
00674     
00675     
00676     virtual ImageRep_ptr HxImageAsVec2Byte(ImageRep_ptr img) = 0;
00677 
00678     
00679     
00680     
00681     virtual ImageRep_ptr HxImageAsVec2Double(ImageRep_ptr img) = 0;
00682 
00683     
00684     
00685     
00686     virtual ImageRep_ptr HxImageAsVec2Float(ImageRep_ptr img) = 0;
00687 
00688     
00689     
00690     
00691     virtual ImageRep_ptr HxImageAsVec2Int(ImageRep_ptr img) = 0;
00692 
00693     
00694     
00695     
00696     virtual ImageRep_ptr HxImageAsVec2Short(ImageRep_ptr img) = 0;
00697 
00698     
00699     
00700     
00701     virtual ImageRep_ptr HxImageAsVec3Byte(ImageRep_ptr img) = 0;
00702 
00703     
00704     
00705     
00706     virtual ImageRep_ptr HxImageAsVec3Double(ImageRep_ptr img) = 0;
00707 
00708     
00709     
00710     
00711     virtual ImageRep_ptr HxImageAsVec3Float(ImageRep_ptr img) = 0;
00712 
00713     
00714     
00715     
00716     virtual ImageRep_ptr HxImageAsVec3Int(ImageRep_ptr img) = 0;
00717 
00718     
00719     
00720     
00721     virtual ImageRep_ptr HxImageAsVec3Short(ImageRep_ptr img) = 0;
00722 
00723     
00724     
00725     
00726     virtual ImageRep_ptr HxImageAsComplex(ImageRep_ptr img) = 0;
00727 
00728     
00729     
00730     
00731     virtual ImageRep_ptr HxColorSpace(ImageRep_ptr im,
00732                                       ColorModel fromColorSpace,
00733                                       ColorModel toColorSpace) = 0;
00734 
00735     
00736     
00737     
00738     virtual ImageRep_ptr HxAffinePix(ImageRep_ptr im,
00739                                      const PixValue& v1,
00740                                      const PixValue& v2,
00741                                      const PixValue& v3) = 0;
00742 
00743     
00744     
00745     
00746     virtual ImageRep_ptr HxRGB2Intensity(ImageRep_ptr im) = 0;
00747 
00748     
00749     
00750     
00751     virtual Histogram_ptr HxGreyEdgeHistogram(ImageRep_ptr objImage,
00752                                               CORBA::Double sigma,
00753                                               CORBA::Double threshold) = 0;
00754 
00755     
00756     
00757     
00758     virtual Histogram_ptr HxHistogramFromFile(const char* fileName) = 0;
00759 
00760     
00761     
00762     
00763     virtual Histogram_ptr HxImageToHistogram(ImageRep_ptr im,
00764                                              CORBA::Long getDim,
00765                                              CORBA::Double lowBin,
00766                                              CORBA::Double highBin,
00767                                              CORBA::Long nBin) = 0;
00768 
00769     
00770     
00771     
00772     virtual Histogram_ptr HxImageToHistogramMask(ImageRep_ptr im,
00773                                                  CORBA::Long getDim,
00774                                                  CORBA::Double lowBin,
00775                                                  CORBA::Double highBin,
00776                                                  CORBA::Long nBin,
00777                                                  ImageRep_ptr mask,
00778                                                  CORBA::Long maskVal) = 0;
00779 
00780     
00781     
00782     
00783     virtual Blob2dSet* HxLabelBlobs(ImageRep_ptr image,
00784                                     ImageRep_ptr mask,
00785                                     CORBA::Long minimalBlobArea) = 0;
00786 
00787     
00788     
00789     
00790     virtual ImageRep_ptr HxHighlightRegion(ImageRep_ptr im,
00791                                            ImageRep_ptr mask,
00792                                            CORBA::Long label,
00793                                            CORBA::Double factor) = 0;
00794 
00795     
00796     
00797     
00798     virtual void HxExportMatlabPixels(ImageRep_ptr im,
00799                                       DoubleSeq& pixels) = 0;
00800 
00801     
00802     
00803     
00804     virtual CORBA::Boolean HxWriteFile(ImageRep_ptr im,
00805                                        const char* fileName) = 0;
00806 
00807     
00808     
00809     
00810     virtual CORBA::Boolean HxImagesToFile(const ImageList& ims,
00811                                           const char* fileName) = 0;
00812 
00813     
00814     
00815     
00816     virtual ImageRep_ptr HxCannyEdgeMap(ImageRep_ptr img,
00817                                         CORBA::Double sigma) = 0;
00818 
00819     
00820     
00821     
00822     virtual ImageRep_ptr HxCannyThreshold(ImageRep_ptr img,
00823                                           CORBA::Double sigma,
00824                                           CORBA::Double level) = 0;
00825 
00826     
00827     
00828     
00829     virtual ImageRep_ptr HxCannyThresholdAlt(ImageRep_ptr img,
00830                                              CORBA::Double sigma,
00831                                              CORBA::Double level) = 0;
00832 
00833     
00834     
00835     
00836     virtual ImageRep_ptr HxCannyThresholdRec(ImageRep_ptr img,
00837                                              CORBA::Double sigma,
00838                                              CORBA::Double level) = 0;
00839 
00840     
00841     
00842     
00843     virtual ImageRep_ptr HxConvGauss2d(ImageRep_ptr img,
00844                                        CORBA::Double sigmax,
00845                                        CORBA::Long orderDerivx,
00846                                        CORBA::Double accuracyx,
00847                                        CORBA::Double sigmay,
00848                                        CORBA::Long orderDerivy,
00849                                        CORBA::Double accuracyy) = 0;
00850 
00851     
00852     
00853     
00854     virtual ImageRep_ptr HxConvGauss3d(ImageRep_ptr img,
00855                                        CORBA::Double sigmax,
00856                                        CORBA::Long orderDerivx,
00857                                        CORBA::Double accuracyx,
00858                                        CORBA::Double sigmay,
00859                                        CORBA::Long orderDerivy,
00860                                        CORBA::Double accuracyy,
00861                                        CORBA::Double sigmaz,
00862                                        CORBA::Long orderDerivz,
00863                                        CORBA::Double accuracyz) = 0;
00864 
00865     
00866     
00867     
00868     virtual ImageRep_ptr HxConvKernelSeparated(ImageRep_ptr im,
00869                                                ImageRep_ptr kernel,
00870                                                ResultPrecision resPrec) = 0;
00871 
00872     
00873     
00874     
00875     virtual ImageRep_ptr HxConvKernelSeparated2d(ImageRep_ptr img,
00876                                                  ImageRep_ptr kernelX,
00877                                                  ImageRep_ptr kernelY,
00878                                                  ResultPrecision resPrec) = 0;
00879 
00880     
00881     
00882     
00883     virtual ImageRep_ptr HxConvolution(ImageRep_ptr im,
00884                                        ImageRep_ptr kernel,
00885                                        ResultPrecision resPrec) = 0;
00886 
00887     
00888     
00889     
00890     virtual ImageRep_ptr HxDefuz(ImageRep_ptr im,
00891                                  CORBA::Long windowSzX,
00892                                  CORBA::Long windowSzY,
00893                                  CORBA::Double thr) = 0;
00894 
00895     
00896     
00897     
00898     virtual ImageRep_ptr HxDistanceTransform(ImageRep_ptr img) = 0;
00899 
00900     
00901     
00902     
00903     virtual ImageRep_ptr HxGauss(ImageRep_ptr img,
00904                                  CORBA::Double sigma,
00905                                  CORBA::Double accuracy) = 0;
00906 
00907     
00908     
00909     
00910     virtual ImageRep_ptr HxGaussDerivative2d(ImageRep_ptr img,
00911                                              CORBA::Double sigma,
00912                                              CORBA::Long orderDerivx,
00913                                              CORBA::Long orderDerivy,
00914                                              CORBA::Double accuracy) = 0;
00915 
00916     
00917     
00918     
00919     virtual ImageRep_ptr HxGaussDerivative3d(ImageRep_ptr img,
00920                                              CORBA::Double sigma,
00921                                              CORBA::Long orderDerivx,
00922                                              CORBA::Long orderDerivy,
00923                                              CORBA::Long orderDerivz,
00924                                              CORBA::Double accuracy) = 0;
00925 
00926     
00927     
00928     
00929     virtual ImageRep_ptr HxGaussianDeblur(ImageRep_ptr im,
00930                                           CORBA::Double dr,
00931                                           CORBA::Double dc) = 0;
00932 
00933     
00934     
00935     
00936     virtual ImageRep_ptr HxKuwahara(ImageRep_ptr im,
00937                                     CORBA::Long width,
00938                                     CORBA::Long height) = 0;
00939 
00940     
00941     
00942     
00943     virtual ImageRep_ptr HxLocalMode(ImageRep_ptr f,
00944                                      ImageRep_ptr g,
00945                                      CORBA::Long nr,
00946                                      CORBA::Double sigmax,
00947                                      CORBA::Double sigmay,
00948                                      CORBA::Double sigmaval,
00949                                      const Sizes& ngbSize) = 0;
00950 
00951     
00952     
00953     
00954     virtual ImageRep_ptr HxNormalizedCorrelation(ImageRep_ptr im,
00955                                                  ImageRep_ptr kernel) = 0;
00956 
00957     
00958     
00959     
00960     virtual ImageRep_ptr HxPercentile(ImageRep_ptr im,
00961                                       CORBA::Long neighSize,
00962                                       CORBA::Double perc) = 0;
00963 
00964     
00965     
00966     
00967     virtual ImageRep_ptr HxRecGabor(ImageRep_ptr im,
00968                                     CORBA::Double s,
00969                                     CORBA::Double omega0,
00970                                     CORBA::Double theta) = 0;
00971 
00972     
00973     
00974     
00975     virtual ImageRep_ptr HxRecGauss(ImageRep_ptr im,
00976                                     CORBA::Double sx,
00977                                     CORBA::Double sy,
00978                                     CORBA::Long dx,
00979                                     CORBA::Long dy,
00980                                     CORBA::Long recurOrder) = 0;
00981 
00982     
00983     
00984     
00985     virtual ImageRep_ptr HxUniform(ImageRep_ptr im,
00986                                    const Sizes& size) = 0;
00987 
00988     
00989     
00990     
00991     virtual ImageRep_ptr HxUniformNonSep(ImageRep_ptr im,
00992                                          const Sizes& size) = 0;
00993 
00994     
00995     
00996     
00997     virtual ImageRep_ptr HxMakeFrom2Images(ImageRep_ptr i1,
00998                                            ImageRep_ptr i2) = 0;
00999 
01000     
01001     
01002     
01003     virtual ImageRep_ptr HxMakeFrom3Images(ImageRep_ptr i1,
01004                                            ImageRep_ptr i2,
01005                                            ImageRep_ptr i3) = 0;
01006 
01007     
01008     
01009     
01010     virtual ImageRep_ptr HxMakeFromByteData(CORBA::Long pixelDimensionality,
01011                                             CORBA::Long dimensions,
01012                                             const Sizes& size,
01013                                             const OctetSeq& data) = 0;
01014 
01015     
01016     
01017     
01018     virtual ImageRep_ptr HxMakeFromDoubleData(CORBA::Long pixelDimensionality,
01019                                               CORBA::Long dimensions,
01020                                               const Sizes& size,
01021                                               const DoubleSeq& data) = 0;
01022 
01023     
01024     
01025     
01026     virtual ImageRep_ptr HxMakeFromFile(const char* fileName) = 0;
01027 
01028     
01029     
01030     
01031     virtual ImageRep_ptr HxMakeFromFloatData(CORBA::Long pixelDimensionality,
01032                                              CORBA::Long dimensions,
01033                                              const Sizes& size,
01034                                              const FloatSeq& data) = 0;
01035 
01036     
01037     
01038     
01039     virtual ImageRep_ptr HxMakeFromGrayValue(ImageSignature signature,
01040                                              const Sizes& size,
01041                                              const OctetSeq& pixels) = 0;
01042 
01043     
01044     
01045     
01046     virtual ImageRep_ptr HxMakeFromImage(ImageSignature signature,
01047                                          ImageRep_ptr src) = 0;
01048 
01049     
01050     
01051     
01052     virtual ImageRep_ptr HxMakeFromImport(ImageSignature signature,
01053                                           const Sizes& size,
01054                                           const char* importOp,
01055                                           TagList_ptr tags) = 0;
01056 
01057     
01058     
01059     
01060     virtual ImageRep_ptr HxMakeFromIntData(CORBA::Long pixelDimensionality,
01061                                            CORBA::Long dimensions,
01062                                            const Sizes& size,
01063                                            const LongSeq& data) = 0;
01064 
01065     
01066     
01067     
01068     virtual ImageRep_ptr HxMakeFromJavaRgb(ImageSignature signature,
01069                                            const Sizes& size,
01070                                            const LongSeq& pixels) = 0;
01071 
01072     
01073     
01074     
01075     virtual ImageRep_ptr HxMakeFromMatlab(ImageSignature signature,
01076                                           const Sizes& size,
01077                                           const DoubleSeq& pixels) = 0;
01078 
01079     
01080     
01081     
01082     virtual ImageRep_ptr HxMakeFromNamedGenerator(ImageSignature signature,
01083                                                   const char* generatorName,
01084                                                   TagList_ptr tags) = 0;
01085 
01086     
01087     
01088     
01089     virtual ImageRep_ptr HxMakeFromPpmPixels(ImageSignature signature,
01090                                              const Sizes& size,
01091                                              const OctetSeq& pixels) = 0;
01092 
01093     
01094     
01095     
01096     virtual ImageRep_ptr HxMakeFromShortData(CORBA::Long pixelDimensionality,
01097                                              CORBA::Long dimensions,
01098                                              const Sizes& size,
01099                                              const ShortSeq& data) = 0;
01100 
01101     
01102     
01103     
01104     virtual ImageRep_ptr HxMakeFromSignature(ImageSignature signature,
01105                                              const Sizes& size) = 0;
01106 
01107     
01108     
01109     
01110     virtual ImageRep_ptr HxMakeFromValue(ImageSignature signature,
01111                                          const Sizes& size,
01112                                          const PixValue& val) = 0;
01113 
01114     
01115     
01116     
01117     virtual ImageRep_ptr HxMakeGaussian1d(CORBA::Double sigma,
01118                                           CORBA::Long deri,
01119                                           CORBA::Double accuracy,
01120                                           CORBA::Long maxfsize,
01121                                           CORBA::Long fsize) = 0;
01122 
01123     
01124     
01125     
01126     virtual ImageRep_ptr HxMakeParabola1d(CORBA::Double rho,
01127                                           CORBA::Double accuracy,
01128                                           CORBA::Long maxfsize,
01129                                           CORBA::Long fsize) = 0;
01130 
01131     
01132     
01133     
01134     virtual ImageList* HxImagesFromFile(const char* fileName) = 0;
01135 
01136     
01137     
01138     
01139     virtual ImageRep_ptr HxExtend(ImageRep_ptr img,
01140                                   ImageRep_ptr background,
01141                                   const Point& begin) = 0;
01142 
01143     
01144     
01145     
01146     virtual ImageRep_ptr HxExtendVal(ImageRep_ptr img,
01147                                      const Sizes& newSize,
01148                                      const PixValue& background,
01149                                      const Point& begin) = 0;
01150 
01151     
01152     
01153     
01154     virtual ImageRep_ptr HxReflect(ImageRep_ptr img,
01155                                    CORBA::Long doX,
01156                                    CORBA::Long doY,
01157                                    CORBA::Long doZ) = 0;
01158 
01159     
01160     
01161     
01162     virtual ImageRep_ptr HxRestrict(ImageRep_ptr img,
01163                                     const Point& begin,
01164                                     const Point& end) = 0;
01165 
01166     
01167     
01168     
01169     virtual ImageRep_ptr HxRotate(ImageRep_ptr img,
01170                                   CORBA::Double alpha,
01171                                   GeoIntType gi,
01172                                   CORBA::Long adjustSize,
01173                                   const PixValue& background) = 0;
01174 
01175     
01176     
01177     
01178     virtual ImageRep_ptr HxScale(ImageRep_ptr img,
01179                                  CORBA::Double sx,
01180                                  CORBA::Double sy,
01181                                  CORBA::Double sz,
01182                                  GeoIntType gi,
01183                                  CORBA::Long adjustSize) = 0;
01184 
01185     
01186     
01187     
01188     virtual ImageRep_ptr HxTranslate(ImageRep_ptr img,
01189                                      CORBA::Long sx,
01190                                      CORBA::Long sy,
01191                                      CORBA::Long sz) = 0;
01192 
01193     
01194     
01195     
01196     virtual ImageRep_ptr HxTranspose(ImageRep_ptr img) = 0;
01197 
01198     
01199     
01200     
01201     virtual CORBA::Long HxImageMaxSize(ImageRep_ptr img) = 0;
01202 
01203     
01204     
01205     
01206     virtual CORBA::Long HxImageMinSize(ImageRep_ptr img) = 0;
01207 
01208     
01209     
01210     
01211     virtual PixValue HxIdentMaskMean(ImageRep_ptr im,
01212                                      ImageRep_ptr mask,
01213                                      const Point& p,
01214                                      const Sizes& size,
01215                                      CORBA::Long label) = 0;
01216 
01217     
01218     
01219     
01220     virtual PixValue HxIdentMaskMedian(ImageRep_ptr im,
01221                                        ImageRep_ptr mask,
01222                                        const Point& p,
01223                                        const Sizes& size,
01224                                        CORBA::Long label) = 0;
01225 
01226     
01227     
01228     
01229     virtual PixValue HxIdentMaskStDev(ImageRep_ptr im,
01230                                       ImageRep_ptr mask,
01231                                       const Point& p,
01232                                       const Sizes& size,
01233                                       CORBA::Long label) = 0;
01234 
01235     
01236     
01237     
01238     virtual PixValue HxIdentMaskSum(ImageRep_ptr im,
01239                                     ImageRep_ptr mask,
01240                                     const Point& p,
01241                                     const Sizes& size,
01242                                     CORBA::Long label) = 0;
01243 
01244     
01245     
01246     
01247     virtual PixValue HxIdentMaskVariance(ImageRep_ptr im,
01248                                          ImageRep_ptr mask,
01249                                          const Point& p,
01250                                          const Sizes& size,
01251                                          CORBA::Long label) = 0;
01252 
01253     
01254     
01255     
01256     virtual PixValue HxWeightMaskSum(ImageRep_ptr im,
01257                                      ImageRep_ptr mask,
01258                                      const Point& p) = 0;
01259 
01260     
01261     
01262     
01263     virtual ImageRep_ptr HxAreaClosing(ImageRep_ptr im,
01264                                        CORBA::Long conn,
01265                                        CORBA::Long minarea) = 0;
01266 
01267     
01268     
01269     
01270     virtual ImageRep_ptr HxAreaOpening(ImageRep_ptr im,
01271                                        CORBA::Long conn,
01272                                        CORBA::Long area) = 0;
01273 
01274     
01275     
01276     
01277     virtual ImageRep_ptr HxClosing(ImageRep_ptr im,
01278                                    SF_ptr s) = 0;
01279 
01280     
01281     
01282     
01283     virtual ImageRep_ptr HxClosingByReconstruction(ImageRep_ptr im,
01284                                                    SF_ptr s1,
01285                                                    SF_ptr s2) = 0;
01286 
01287     
01288     
01289     
01290     virtual ImageRep_ptr HxClosingByReconstructionTopHat(ImageRep_ptr im,
01291                                                          SF_ptr s1,
01292                                                          SF_ptr s2) = 0;
01293 
01294     
01295     
01296     
01297     virtual ImageRep_ptr HxClosingTopHat(ImageRep_ptr im,
01298                                          SF_ptr s) = 0;
01299 
01300     
01301     
01302     
01303     virtual ImageRep_ptr HxConditionalDilation(ImageRep_ptr im,
01304                                                ImageRep_ptr mask,
01305                                                SF_ptr s,
01306                                                CORBA::Long nrIter) = 0;
01307 
01308     
01309     
01310     
01311     virtual ImageRep_ptr HxConditionalErosion(ImageRep_ptr im,
01312                                               ImageRep_ptr mask,
01313                                               SF_ptr s,
01314                                               CORBA::Long nrIter) = 0;
01315 
01316     
01317     
01318     
01319     virtual ImageRep_ptr HxDilation(ImageRep_ptr im,
01320                                     SF_ptr s) = 0;
01321 
01322     
01323     
01324     
01325     virtual ImageRep_ptr HxDistanceTransformMM(ImageRep_ptr im,
01326                                                SF_ptr s) = 0;
01327 
01328     
01329     
01330     
01331     virtual ImageRep_ptr HxErosion(ImageRep_ptr im,
01332                                    SF_ptr s) = 0;
01333 
01334     
01335     
01336     
01337     virtual ImageRep_ptr HxGeodesicDistanceTransform(ImageRep_ptr im,
01338                                                      CORBA::Long conn) = 0;
01339 
01340     
01341     
01342     
01343     virtual ImageRep_ptr HxHilditchSkeleton(ImageRep_ptr im) = 0;
01344 
01345     
01346     
01347     
01348     virtual ImageRep_ptr HxHitOrMiss(ImageRep_ptr im,
01349                                      SF_ptr s1,
01350                                      SF_ptr s2) = 0;
01351 
01352     
01353     
01354     
01355     virtual ImageRep_ptr HxInfimumReconstruction(ImageRep_ptr im,
01356                                                  ImageRep_ptr mask,
01357                                                  SF_ptr s) = 0;
01358 
01359     
01360     
01361     
01362     virtual ImageRep_ptr HxMorphologicalContour(ImageRep_ptr im,
01363                                                 SF_ptr s) = 0;
01364 
01365     
01366     
01367     
01368     virtual ImageRep_ptr HxMorphologicalGradient(ImageRep_ptr im,
01369                                                  SF_ptr s) = 0;
01370 
01371     
01372     
01373     
01374     virtual ImageRep_ptr HxMorphologicalGradient2(ImageRep_ptr im,
01375                                                   SF_ptr s1,
01376                                                   SF_ptr s2) = 0;
01377 
01378     
01379     
01380     
01381     virtual ImageRep_ptr HxOpening(ImageRep_ptr im,
01382                                    SF_ptr s) = 0;
01383 
01384     
01385     
01386     
01387     virtual ImageRep_ptr HxOpeningByReconstruction(ImageRep_ptr im,
01388                                                    SF_ptr s1,
01389                                                    SF_ptr s2) = 0;
01390 
01391     
01392     
01393     
01394     virtual ImageRep_ptr HxOpeningByReconstructionTopHat(ImageRep_ptr im,
01395                                                          SF_ptr s1,
01396                                                          SF_ptr s2) = 0;
01397 
01398     
01399     
01400     
01401     virtual ImageRep_ptr HxOpeningTopHat(ImageRep_ptr im,
01402                                          SF_ptr s) = 0;
01403 
01404     
01405     
01406     
01407     virtual ImageRep_ptr HxParabolicDilation(ImageRep_ptr img,
01408                                              CORBA::Double rho,
01409                                              CORBA::Double accuracy) = 0;
01410 
01411     
01412     
01413     
01414     virtual ImageRep_ptr HxParabolicErosion(ImageRep_ptr img,
01415                                             CORBA::Double rho,
01416                                             CORBA::Double accuracy) = 0;
01417 
01418     
01419     
01420     
01421     virtual ImageRep_ptr HxPeakRemoval(ImageRep_ptr im,
01422                                        CORBA::Long conn,
01423                                        CORBA::Long minarea) = 0;
01424 
01425     
01426     
01427     
01428     virtual ImageRep_ptr HxRegionalMaxima(ImageRep_ptr im,
01429                                           CORBA::Long conn) = 0;
01430 
01431     
01432     
01433     
01434     virtual ImageRep_ptr HxRegionalMinima(ImageRep_ptr im,
01435                                           CORBA::Long conn) = 0;
01436 
01437     
01438     
01439     
01440     virtual ImageRep_ptr HxSKIZ(ImageRep_ptr im,
01441                                 CORBA::Long conn) = 0;
01442 
01443     
01444     
01445     
01446     virtual ImageRep_ptr HxSkeleton(ImageRep_ptr im,
01447                                     SF_ptr s) = 0;
01448 
01449     
01450     
01451     
01452     virtual ImageRep_ptr HxSupremumReconstruction(ImageRep_ptr im,
01453                                                   ImageRep_ptr mask,
01454                                                   SF_ptr s) = 0;
01455 
01456     
01457     
01458     
01459     virtual ImageRep_ptr HxThickening(ImageRep_ptr im,
01460                                       SF_ptr s1,
01461                                       SF_ptr s2) = 0;
01462 
01463     
01464     
01465     
01466     virtual ImageRep_ptr HxThinning(ImageRep_ptr im,
01467                                     SF_ptr s1,
01468                                     SF_ptr s2) = 0;
01469 
01470     
01471     
01472     
01473     virtual ImageRep_ptr HxValleyRemoval(ImageRep_ptr im,
01474                                          CORBA::Long conn,
01475                                          CORBA::Long minarea) = 0;
01476 
01477     
01478     
01479     
01480     virtual ImageRep_ptr HxWatershed(ImageRep_ptr im,
01481                                      CORBA::Long conn) = 0;
01482 
01483     
01484     
01485     
01486     virtual ImageRep_ptr HxWatershedMarkers(ImageRep_ptr input,
01487                                             ImageRep_ptr mask,
01488                                             CORBA::Long conn,
01489                                             CORBA::Boolean doLabelMask) = 0;
01490 
01491     
01492     
01493     
01494     virtual ImageRep_ptr HxWatershedMarkers2(ImageRep_ptr input,
01495                                              ImageRep_ptr mask,
01496                                              CORBA::Long conn,
01497                                              CORBA::Boolean doLabelMask,
01498                                              CORBA::Long costMethod) = 0;
01499 
01500     
01501     
01502     
01503     virtual ImageRep_ptr HxWatershedSlow(ImageRep_ptr im,
01504                                          SF_ptr s,
01505                                          const char* linereg) = 0;
01506 
01507     
01508     
01509     
01510     virtual ImageRep_ptr HxDisplayOF(ImageRep_ptr im,
01511                                      CORBA::Long scale_x,
01512                                      CORBA::Long scale_y,
01513                                      CORBA::Double mul_x,
01514                                      CORBA::Double mul_y,
01515                                      CORBA::Long pixelsize) = 0;
01516 
01517     
01518     
01519     
01520     virtual ImageRep_ptr HxOpticalFlow(ImageRep_ptr im1,
01521                                        ImageRep_ptr im2) = 0;
01522 
01523     
01524     
01525     
01526     virtual ImageRep_ptr HxOpticalFlowMultiScale(ImageRep_ptr im1,
01527                                                  ImageRep_ptr im2) = 0;
01528 
01529     
01530     
01531     
01532     virtual ImageRep_ptr HxAddBinaryNoise(ImageRep_ptr im,
01533                                           CORBA::Double percent) = 0;
01534 
01535     
01536     
01537     
01538     virtual ImageRep_ptr HxAddGaussianNoise(ImageRep_ptr im,
01539                                             CORBA::Double mean,
01540                                             CORBA::Double stdev) = 0;
01541 
01542     
01543     
01544     
01545     virtual ImageRep_ptr HxAddPoissonNoise(ImageRep_ptr im,
01546                                            CORBA::Double conversionFactor) = 0;
01547 
01548     
01549     
01550     
01551     virtual ImageRep_ptr HxAddUniformNoise(ImageRep_ptr im) = 0;
01552 
01553     
01554     
01555     
01556     virtual ImageRep_ptr HxContrastStretch(ImageRep_ptr im,
01557                                            CORBA::Double val) = 0;
01558 
01559     
01560     
01561     
01562     virtual ImageRep_ptr HxSetBorderValue(ImageRep_ptr im,
01563                                           CORBA::Long w,
01564                                           CORBA::Long h,
01565                                           const PixValue& val) = 0;
01566 
01567     
01568     
01569     
01570     virtual ImageRep_ptr HxSetPartImage(ImageRep_ptr im,
01571                                         CORBA::Long x1,
01572                                         CORBA::Long y1,
01573                                         CORBA::Long x2,
01574                                         CORBA::Long y2,
01575                                         const PixValue& val) = 0;
01576 
01577     
01578     
01579     
01580     virtual ImageRep_ptr HxSquaredDistance(ImageRep_ptr im1,
01581                                            ImageRep_ptr im2) = 0;
01582 
01583     
01584     
01585     
01586     virtual ImageRep_ptr HxBernsenThreshold(ImageRep_ptr im,
01587                                             CORBA::Long windowSz,
01588                                             CORBA::Long uniformTh,
01589                                             CORBA::Boolean uniformLow) = 0;
01590 
01591     
01592     
01593     
01594     virtual ImageRep_ptr HxColorGaborSegmentation(ImageRep_ptr im,
01595                                                   ColorGaborSegmentationAlgorithm segAlg,
01596                                                   ColorGaborSegmentationInvariant invariantType,
01597                                                   CORBA::Double minRegionFraction,
01598                                                   CORBA::Double threshold) = 0;
01599 
01600     
01601     
01602     
01603     virtual ImageRep_ptr HxEntropyThreshold(ImageRep_ptr im) = 0;
01604 
01605     
01606     
01607     
01608     virtual ImageRep_ptr HxIsodataThreshold(ImageRep_ptr im) = 0;
01609 
01610     
01611     
01612     
01613     virtual ImageRep_ptr HxLabel(ImageRep_ptr im,
01614                                  CORBA::Long conn) = 0;
01615 
01616     
01617     
01618     
01619     virtual ImageRep_ptr HxLabel2(ImageRep_ptr im,
01620                                   CORBA::Long conn) = 0;
01621 
01622     
01623     
01624     
01625     virtual ImageRep_ptr HxThreshold(ImageRep_ptr im,
01626                                      const PixValue& val) = 0;
01627 
01628     
01629     
01630     
01631     virtual ImageRep_ptr HxTriStateThreshold(ImageRep_ptr im,
01632                                              const PixValue& level,
01633                                              const PixValue& v1,
01634                                              const PixValue& v2,
01635                                              const PixValue& v3) = 0;
01636 
01637     
01638     
01639     
01640     virtual CORBA::Boolean VxRelEquals(const VxTimeSpan& elt1,
01641                                        const VxTimeSpan& elt2) = 0;
01642 
01643     
01644     
01645     
01646     virtual CORBA::Boolean VxRelMeets(const VxTimeSpan& elt1,
01647                                       const VxTimeSpan& elt2) = 0;
01648 
01649     
01650     
01651     
01652     virtual CORBA::Boolean VxRelBefore(const VxTimeSpan& elt1,
01653                                        const VxTimeSpan& elt2) = 0;
01654 
01655     
01656     
01657     
01658     virtual CORBA::Boolean VxRelOverlaps(const VxTimeSpan& elt1,
01659                                          const VxTimeSpan& elt2) = 0;
01660 
01661     
01662     
01663     
01664     virtual CORBA::Boolean VxRelDur(const VxTimeSpan& elt1,
01665                                     const VxTimeSpan& elt2) = 0;
01666 
01667     
01668     
01669     
01670     virtual CORBA::Boolean VxRelCon(const VxTimeSpan& elt1,
01671                                     const VxTimeSpan& elt2) = 0;
01672 
01673     
01674     
01675     
01676     virtual CORBA::Boolean VxRelMeetsAnywhere(const VxTimeSpan& elt1,
01677                                               const VxTimeSpan& elt2) = 0;
01678 
01679     
01680     
01681     
01682     virtual CORBA::Boolean VxRelBeforeAfter(const VxTimeSpan& elt1,
01683                                             const VxTimeSpan& elt2) = 0;
01684 
01685     
01686     
01687     
01688     virtual CORBA::Boolean VxRelOverlapsAnywhere(const VxTimeSpan& elt1,
01689                                                  const VxTimeSpan& elt2) = 0;
01690 
01691     
01692     
01693     
01694     virtual char* VxRelAsString(const VxTimeSpan& elt1,
01695                                 const VxTimeSpan& elt2) = 0;
01696 
01697     
01698     
01699     
01700     virtual void HxIDBOpen(const char* name,
01701                            const char* indexFile) = 0;
01702 
01703     
01704     
01705     
01706     virtual StringSeq* HxIDBRandom(const char* name,
01707                                    CORBA::Long n) = 0;
01708 
01709     
01710     
01711     
01712     virtual StringSeq* HxIDBSearch(const char* key,
01713                                    const char* name,
01714                                    CORBA::Long n) = 0;
01715 
01716     
01717     
01718     
01719     virtual void HxInvarOpenDB(const char* indexFile,
01720                                const char* dbDir) = 0;
01721 
01722     
01723     
01724     
01725     virtual StringSeq* HxInvarRandom(const char* invar,
01726                                      CORBA::Long n) = 0;
01727 
01728     
01729     
01730     
01731     virtual StringSeq* HxInvarSearch(ImageRep_ptr im,
01732                                      const char* invar,
01733                                      CORBA::Long n) = 0;
01734 
01735     
01736     
01737     
01738     virtual StringSeq* HxInvarSearchHisto(const HistogramList& target,
01739                                           const char* invar,
01740                                           CORBA::Long n) = 0;
01741 
01742     
01743     
01744     
01745     virtual CORBA::Double HxInvarMatchHistos(const HistogramList& l1,
01746                                              const HistogramList& l2) = 0;
01747 
01748     
01749     
01750     
01751     virtual void HxInvarIndexDB(const char* indexFile,
01752                                 const char* dbDir,
01753                                 const char* invar,
01754                                 CORBA::Double s,
01755                                 CORBA::Long bins) = 0;
01756 
01757     
01758     
01759     
01760     virtual CORBA::Long HxInvarDBSize(const char* invar) = 0;
01761 
01762     
01763     
01764     
01765     virtual CORBA::Long HxInvarBinsPerHistogram(const char* invar) = 0;
01766 
01767     
01768     
01769     
01770     virtual CORBA::Long HxInvarChannels(const char* invar) = 0;
01771 
01772     
01773     
01774     
01775     virtual StringSeq* HxInvarDBList(const char* invar) = 0;
01776 
01777     
01778     
01779     
01780     virtual FloatSeq* HxInvarGetHistos(const char* invar,
01781                                        const char* key) = 0;
01782 
01783     
01784     
01785     
01786     virtual StringSeq* HxInvarSearchKey(const char* key,
01787                                         const char* invar,
01788                                         CORBA::Long n) = 0;
01789 
01790     
01791     
01792     
01793     virtual DoubleSeq* HxInvarScores(const char* invar,
01794                                      CORBA::Long n) = 0;
01795 
01796     
01797     
01798     
01799     virtual ImageRep_ptr HxNJetInvarE(NJet_ptr nj) = 0;
01800 
01801     
01802     
01803     
01804     virtual ImageRep_ptr HxNJetInvarC(NJet_ptr nj) = 0;
01805 
01806     
01807     
01808     
01809     virtual ImageRep_ptr HxNJetInvarWw(NJet_ptr nj) = 0;
01810 
01811     
01812     
01813     
01814     virtual ImageRep_ptr HxNJetInvarCw(NJet_ptr nj) = 0;
01815 
01816     
01817     
01818     
01819     virtual HistogramList* HxNJetInvarEHisto(NJet_ptr nj,
01820                                              CORBA::Long nBin) = 0;
01821 
01822     
01823     
01824     
01825     virtual HistogramList* HxNJetInvarCHisto(NJet_ptr nj,
01826                                              CORBA::Long nBin) = 0;
01827 
01828     
01829     
01830     
01831     virtual HistogramList* HxNJetInvarWwHisto(NJet_ptr nj,
01832                                               CORBA::Long nBin) = 0;
01833 
01834     
01835     
01836     
01837     virtual HistogramList* HxNJetInvarCwHisto(NJet_ptr nj,
01838                                               CORBA::Long nBin) = 0;
01839 
01840     
01841     
01842     
01843     virtual HistogramList* HxInvarEHisto(ImageRep_ptr im,
01844                                          CORBA::Double scale,
01845                                          CORBA::Long nBin) = 0;
01846 
01847     
01848     
01849     
01850     virtual HistogramList* HxInvarCHisto(ImageRep_ptr im,
01851                                          CORBA::Double scale,
01852                                          CORBA::Long nBin) = 0;
01853 
01854     
01855     
01856     
01857     virtual HistogramList* HxInvarWwHisto(ImageRep_ptr im,
01858                                           CORBA::Double scale,
01859                                           CORBA::Long nBin) = 0;
01860 
01861     
01862     
01863     
01864     virtual HistogramList* HxInvarCwHisto(ImageRep_ptr im,
01865                                           CORBA::Double scale,
01866                                           CORBA::Long nBin) = 0;
01867 
01868     
01869     
01870     
01871     virtual DoubleSeqSeq* HxNJetInvar(ImageRep_ptr im,
01872                                       const char* invar,
01873                                       CORBA::Double scale,
01874                                       CORBA::Long nBin) = 0;
01875 
01876     
01877     
01878     
01879     virtual ImageRep_ptr HxColorInvarEw(ImageRep_ptr im,
01880                                         CORBA::Double scale) = 0;
01881 
01882     
01883     
01884     
01885     virtual ImageRep_ptr HxColorInvarWw(ImageRep_ptr im,
01886                                         CORBA::Double scale) = 0;
01887 
01888     
01889     
01890     
01891     virtual ImageRep_ptr HxColorInvarCw(ImageRep_ptr im,
01892                                         CORBA::Double scale) = 0;
01893 
01894     
01895     
01896     
01897     virtual ImageRep_ptr HxColorInvarNw(ImageRep_ptr im,
01898                                         CORBA::Double scale) = 0;
01899 
01900     
01901     
01902     
01903     virtual ImageRep_ptr HxColorInvarHw(ImageRep_ptr im,
01904                                         CORBA::Double scale) = 0;
01905 };
01906 
01907 } 
01908 
01909 
01910 
01911 
01912 namespace OBProxy_HxCorba
01913 {
01914 
01915 
01916 
01917 
01918 class GlobalOps : virtual public ::HxCorba::GlobalOps,
01919                   virtual public OBProxy_HxCorba::UserOps
01920 {
01921     GlobalOps(const GlobalOps&);
01922     void operator=(const GlobalOps&);
01923 
01924 protected:
01925 
01926     virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01927 
01928 public:
01929 
01930     GlobalOps() { }
01931     virtual ~GlobalOps() { }
01932 
01933     virtual const char** _OB_ids() const;
01934 
01935     
01936     
01937     
01938     ::HxCorba::ImageRep_ptr HxAbs(::HxCorba::ImageRep_ptr im);
01939 
01940     
01941     
01942     
01943     ::HxCorba::ImageRep_ptr HxCeil(::HxCorba::ImageRep_ptr im);
01944 
01945     
01946     
01947     
01948     ::HxCorba::ImageRep_ptr HxComplement(::HxCorba::ImageRep_ptr im);
01949 
01950     
01951     
01952     
01953     ::HxCorba::ImageRep_ptr HxExp(::HxCorba::ImageRep_ptr im);
01954 
01955     
01956     
01957     
01958     ::HxCorba::ImageRep_ptr HxFloor(::HxCorba::ImageRep_ptr im);
01959 
01960     
01961     
01962     
01963     ::HxCorba::ImageRep_ptr HxLog(::HxCorba::ImageRep_ptr im);
01964 
01965     
01966     
01967     
01968     ::HxCorba::ImageRep_ptr HxLog10(::HxCorba::ImageRep_ptr im);
01969 
01970     
01971     
01972     
01973     ::HxCorba::ImageRep_ptr HxNegate(::HxCorba::ImageRep_ptr im);
01974 
01975     
01976     
01977     
01978     ::HxCorba::ImageRep_ptr HxNorm1(::HxCorba::ImageRep_ptr im);
01979 
01980     
01981     
01982     
01983     ::HxCorba::ImageRep_ptr HxNorm2(::HxCorba::ImageRep_ptr im);
01984 
01985     
01986     
01987     
01988     ::HxCorba::ImageRep_ptr HxNormInf(::HxCorba::ImageRep_ptr im);
01989 
01990     
01991     
01992     
01993     ::HxCorba::ImageRep_ptr HxProjectRange(::HxCorba::ImageRep_ptr im,
01994                                            CORBA::Long dimension);
01995 
01996     
01997     
01998     
01999     ::HxCorba::ImageRep_ptr HxReciprocal(::HxCorba::ImageRep_ptr im);
02000 
02001     
02002     
02003     
02004     ::HxCorba::ImageRep_ptr HxSqrt(::HxCorba::ImageRep_ptr im);
02005 
02006     
02007     
02008     
02009     ::HxCorba::ImageRep_ptr HxRound(::HxCorba::ImageRep_ptr im);
02010 
02011     
02012     
02013     
02014     ::HxCorba::ImageRep_ptr HxUnaryMax(::HxCorba::ImageRep_ptr im);
02015 
02016     
02017     
02018     
02019     ::HxCorba::ImageRep_ptr HxUnaryMin(::HxCorba::ImageRep_ptr im);
02020 
02021     
02022     
02023     
02024     ::HxCorba::ImageRep_ptr HxUnaryProduct(::HxCorba::ImageRep_ptr im);
02025 
02026     
02027     
02028     
02029     ::HxCorba::ImageRep_ptr HxUnarySum(::HxCorba::ImageRep_ptr im);
02030 
02031     
02032     
02033     
02034     ::HxCorba::ImageRep_ptr HxAcos(::HxCorba::ImageRep_ptr im);
02035 
02036     
02037     
02038     
02039     ::HxCorba::ImageRep_ptr HxAsin(::HxCorba::ImageRep_ptr im);
02040 
02041     
02042     
02043     
02044     ::HxCorba::ImageRep_ptr HxAtan(::HxCorba::ImageRep_ptr im);
02045 
02046     
02047     
02048     
02049     ::HxCorba::ImageRep_ptr HxAtan2(::HxCorba::ImageRep_ptr im);
02050 
02051     
02052     
02053     
02054     ::HxCorba::ImageRep_ptr HxCos(::HxCorba::ImageRep_ptr im);
02055 
02056     
02057     
02058     
02059     ::HxCorba::ImageRep_ptr HxCosh(::HxCorba::ImageRep_ptr im);
02060 
02061     
02062     
02063     
02064     ::HxCorba::ImageRep_ptr HxSin(::HxCorba::ImageRep_ptr im);
02065 
02066     
02067     
02068     
02069     ::HxCorba::ImageRep_ptr HxSinh(::HxCorba::ImageRep_ptr im);
02070 
02071     
02072     
02073     
02074     ::HxCorba::ImageRep_ptr HxTan(::HxCorba::ImageRep_ptr im);
02075 
02076     
02077     
02078     
02079     ::HxCorba::ImageRep_ptr HxTanh(::HxCorba::ImageRep_ptr im);
02080 
02081     
02082     
02083     
02084     ::HxCorba::ImageRep_ptr HxArg(::HxCorba::ImageRep_ptr im);
02085 
02086     
02087     
02088     
02089     ::HxCorba::ImageRep_ptr HxConjugate(::HxCorba::ImageRep_ptr im);
02090 
02091     
02092     
02093     
02094     ::HxCorba::ImageRep_ptr HxAdd(::HxCorba::ImageRep_ptr im1,
02095                                   ::HxCorba::ImageRep_ptr im2);
02096 
02097     
02098     
02099     
02100     ::HxCorba::ImageRep_ptr HxAddSat(::HxCorba::ImageRep_ptr im1,
02101                                      ::HxCorba::ImageRep_ptr im2);
02102 
02103     
02104     
02105     
02106     ::HxCorba::ImageRep_ptr HxAnd(::HxCorba::ImageRep_ptr im1,
02107                                   ::HxCorba::ImageRep_ptr im2);
02108 
02109     
02110     
02111     
02112     ::HxCorba::ImageRep_ptr HxCross(::HxCorba::ImageRep_ptr im1,
02113                                     ::HxCorba::ImageRep_ptr im2);
02114 
02115     
02116     
02117     
02118     ::HxCorba::ImageRep_ptr HxDiv(::HxCorba::ImageRep_ptr im1,
02119                                   ::HxCorba::ImageRep_ptr im2);
02120 
02121     
02122     
02123     
02124     ::HxCorba::ImageRep_ptr HxDot(::HxCorba::ImageRep_ptr im1,
02125                                   ::HxCorba::ImageRep_ptr im2);
02126 
02127     
02128     
02129     
02130     ::HxCorba::ImageRep_ptr HxEqual(::HxCorba::ImageRep_ptr im1,
02131                                     ::HxCorba::ImageRep_ptr im2);
02132 
02133     
02134     
02135     
02136     ::HxCorba::ImageRep_ptr HxGreaterEqual(::HxCorba::ImageRep_ptr im1,
02137                                            ::HxCorba::ImageRep_ptr im2);
02138 
02139     
02140     
02141     
02142     ::HxCorba::ImageRep_ptr HxGreaterThan(::HxCorba::ImageRep_ptr im1,
02143                                           ::HxCorba::ImageRep_ptr im2);
02144 
02145     
02146     
02147     
02148     ::HxCorba::ImageRep_ptr HxInf(::HxCorba::ImageRep_ptr im1,
02149                                   ::HxCorba::ImageRep_ptr im2);
02150 
02151     
02152     
02153     
02154     ::HxCorba::ImageRep_ptr HxInverseProjectRange(::HxCorba::ImageRep_ptr im1,
02155                                                   CORBA::Long dimension,
02156                                                   ::HxCorba::ImageRep_ptr im2);
02157 
02158     
02159     
02160     
02161     ::HxCorba::ImageRep_ptr HxLeftShift(::HxCorba::ImageRep_ptr im1,
02162                                         ::HxCorba::ImageRep_ptr im2);
02163 
02164     
02165     
02166     
02167     ::HxCorba::ImageRep_ptr HxLessEqual(::HxCorba::ImageRep_ptr im1,
02168                                         ::HxCorba::ImageRep_ptr im2);
02169 
02170     
02171     
02172     
02173     ::HxCorba::ImageRep_ptr HxLessThan(::HxCorba::ImageRep_ptr im1,
02174                                        ::HxCorba::ImageRep_ptr im2);
02175 
02176     
02177     
02178     
02179     ::HxCorba::ImageRep_ptr HxMax(::HxCorba::ImageRep_ptr im1,
02180                                   ::HxCorba::ImageRep_ptr im2);
02181 
02182     
02183     
02184     
02185     ::HxCorba::ImageRep_ptr HxMin(::HxCorba::ImageRep_ptr im1,
02186                                   ::HxCorba::ImageRep_ptr im2);
02187 
02188     
02189     
02190     
02191     ::HxCorba::ImageRep_ptr HxMod(::HxCorba::ImageRep_ptr im1,
02192                                   ::HxCorba::ImageRep_ptr im2);
02193 
02194     
02195     
02196     
02197     ::HxCorba::ImageRep_ptr HxMul(::HxCorba::ImageRep_ptr im1,
02198                                   ::HxCorba::ImageRep_ptr im2);
02199 
02200     
02201     
02202     
02203     ::HxCorba::ImageRep_ptr HxNotEqual(::HxCorba::ImageRep_ptr im1,
02204                                        ::HxCorba::ImageRep_ptr im2);
02205 
02206     
02207     
02208     
02209     ::HxCorba::ImageRep_ptr HxOr(::HxCorba::ImageRep_ptr im1,
02210                                  ::HxCorba::ImageRep_ptr im2);
02211 
02212     
02213     
02214     
02215     ::HxCorba::ImageRep_ptr HxPow(::HxCorba::ImageRep_ptr im1,
02216                                   ::HxCorba::ImageRep_ptr im2);
02217 
02218     
02219     
02220     
02221     ::HxCorba::ImageRep_ptr HxRightShift(::HxCorba::ImageRep_ptr im1,
02222                                          ::HxCorba::ImageRep_ptr im2);
02223 
02224     
02225     
02226     
02227     ::HxCorba::ImageRep_ptr HxSub(::HxCorba::ImageRep_ptr im1,
02228                                   ::HxCorba::ImageRep_ptr im2);
02229 
02230     
02231     
02232     
02233     ::HxCorba::ImageRep_ptr HxSubSat(::HxCorba::ImageRep_ptr im1,
02234                                      ::HxCorba::ImageRep_ptr im2);
02235 
02236     
02237     
02238     
02239     ::HxCorba::ImageRep_ptr HxSup(::HxCorba::ImageRep_ptr im1,
02240                                   ::HxCorba::ImageRep_ptr im2);
02241 
02242     
02243     
02244     
02245     ::HxCorba::ImageRep_ptr HxXor(::HxCorba::ImageRep_ptr im1,
02246                                   ::HxCorba::ImageRep_ptr im2);
02247 
02248     
02249     
02250     
02251     ::HxCorba::ImageRep_ptr HxAddVal(::HxCorba::ImageRep_ptr im,
02252                                      const ::HxCorba::PixValue& val);
02253 
02254     
02255     
02256     
02257     ::HxCorba::ImageRep_ptr HxAndVal(::HxCorba::ImageRep_ptr im,
02258                                      const ::HxCorba::PixValue& val);
02259 
02260     
02261     
02262     
02263     ::HxCorba::ImageRep_ptr HxCrossVal(::HxCorba::ImageRep_ptr im,
02264                                        const ::HxCorba::PixValue& val);
02265 
02266     
02267     
02268     
02269     ::HxCorba::ImageRep_ptr HxDivVal(::HxCorba::ImageRep_ptr im,
02270                                      const ::HxCorba::PixValue& val);
02271 
02272     
02273     
02274     
02275     ::HxCorba::ImageRep_ptr HxDotVal(::HxCorba::ImageRep_ptr im,
02276                                      const ::HxCorba::PixValue& val);
02277 
02278     
02279     
02280     
02281     ::HxCorba::ImageRep_ptr HxEqualVal(::HxCorba::ImageRep_ptr im,
02282                                        const ::HxCorba::PixValue& val);
02283 
02284     
02285     
02286     
02287     ::HxCorba::ImageRep_ptr HxGreaterEqualVal(::HxCorba::ImageRep_ptr im,
02288                                               const ::HxCorba::PixValue& val);
02289 
02290     
02291     
02292     
02293     ::HxCorba::ImageRep_ptr HxGreaterThanVal(::HxCorba::ImageRep_ptr im,
02294                                              const ::HxCorba::PixValue& val);
02295 
02296     
02297     
02298     
02299     ::HxCorba::ImageRep_ptr HxInfVal(::HxCorba::ImageRep_ptr im,
02300                                      const ::HxCorba::PixValue& val);
02301 
02302     
02303     
02304     
02305     ::HxCorba::ImageRep_ptr HxLeftShiftVal(::HxCorba::ImageRep_ptr im,
02306                                            const ::HxCorba::PixValue& val);
02307 
02308     
02309     
02310     
02311     ::HxCorba::ImageRep_ptr HxLessEqualVal(::HxCorba::ImageRep_ptr im,
02312                                            const ::HxCorba::PixValue& val);
02313 
02314     
02315     
02316     
02317     ::HxCorba::ImageRep_ptr HxLessThanVal(::HxCorba::ImageRep_ptr im,
02318                                           const ::HxCorba::PixValue& val);
02319 
02320     
02321     
02322     
02323     ::HxCorba::ImageRep_ptr HxMaxVal(::HxCorba::ImageRep_ptr im,
02324                                      const ::HxCorba::PixValue& val);
02325 
02326     
02327     
02328     
02329     ::HxCorba::ImageRep_ptr HxMinVal(::HxCorba::ImageRep_ptr im,
02330                                      const ::HxCorba::PixValue& val);
02331 
02332     
02333     
02334     
02335     ::HxCorba::ImageRep_ptr HxModVal(::HxCorba::ImageRep_ptr im,
02336                                      const ::HxCorba::PixValue& val);
02337 
02338     
02339     
02340     
02341     ::HxCorba::ImageRep_ptr HxMulVal(::HxCorba::ImageRep_ptr im,
02342                                      const ::HxCorba::PixValue& val);
02343 
02344     
02345     
02346     
02347     ::HxCorba::ImageRep_ptr HxNotEqualVal(::HxCorba::ImageRep_ptr im,
02348                                           const ::HxCorba::PixValue& val);
02349 
02350     
02351     
02352     
02353     ::HxCorba::ImageRep_ptr HxOrVal(::HxCorba::ImageRep_ptr im,
02354                                     const ::HxCorba::PixValue& val);
02355 
02356     
02357     
02358     
02359     ::HxCorba::ImageRep_ptr HxPowVal(::HxCorba::ImageRep_ptr im,
02360                                      const ::HxCorba::PixValue& val);
02361 
02362     
02363     
02364     
02365     ::HxCorba::ImageRep_ptr HxRightShiftVal(::HxCorba::ImageRep_ptr im,
02366                                             const ::HxCorba::PixValue& val);
02367 
02368     
02369     
02370     
02371     ::HxCorba::ImageRep_ptr HxSubVal(::HxCorba::ImageRep_ptr im,
02372                                      const ::HxCorba::PixValue& val);
02373 
02374     
02375     
02376     
02377     ::HxCorba::ImageRep_ptr HxSupVal(::HxCorba::ImageRep_ptr im,
02378                                      const ::HxCorba::PixValue& val);
02379 
02380     
02381     
02382     
02383     ::HxCorba::ImageRep_ptr HxXorVal(::HxCorba::ImageRep_ptr im,
02384                                      const ::HxCorba::PixValue& val);
02385 
02386     
02387     
02388     
02389     ::HxCorba::PixValue HxPixInf(::HxCorba::ImageRep_ptr im);
02390 
02391     
02392     
02393     
02394     ::HxCorba::PixValue HxPixMax(::HxCorba::ImageRep_ptr im);
02395 
02396     
02397     
02398     
02399     ::HxCorba::PixValue HxPixMin(::HxCorba::ImageRep_ptr im);
02400 
02401     
02402     
02403     
02404     ::HxCorba::PixValue HxPixProduct(::HxCorba::ImageRep_ptr im);
02405 
02406     
02407     
02408     
02409     ::HxCorba::PixValue HxPixSum(::HxCorba::ImageRep_ptr im);
02410 
02411     
02412     
02413     
02414     ::HxCorba::PixValue HxPixSup(::HxCorba::ImageRep_ptr im);
02415 
02416     
02417     
02418     
02419     ::HxCorba::ImageRep_ptr HxImageAsByte(::HxCorba::ImageRep_ptr img);
02420 
02421     
02422     
02423     
02424     ::HxCorba::ImageRep_ptr HxImageAsDouble(::HxCorba::ImageRep_ptr img);
02425 
02426     
02427     
02428     
02429     ::HxCorba::ImageRep_ptr HxImageAsFloat(::HxCorba::ImageRep_ptr img);
02430 
02431     
02432     
02433     
02434     ::HxCorba::ImageRep_ptr HxImageAsShort(::HxCorba::ImageRep_ptr img);
02435 
02436     
02437     
02438     
02439     ::HxCorba::ImageRep_ptr HxImageAsVec2Byte(::HxCorba::ImageRep_ptr img);
02440 
02441     
02442     
02443     
02444     ::HxCorba::ImageRep_ptr HxImageAsVec2Double(::HxCorba::ImageRep_ptr img);
02445 
02446     
02447     
02448     
02449     ::HxCorba::ImageRep_ptr HxImageAsVec2Float(::HxCorba::ImageRep_ptr img);
02450 
02451     
02452     
02453     
02454     ::HxCorba::ImageRep_ptr HxImageAsVec2Int(::HxCorba::ImageRep_ptr img);
02455 
02456     
02457     
02458     
02459     ::HxCorba::ImageRep_ptr HxImageAsVec2Short(::HxCorba::ImageRep_ptr img);
02460 
02461     
02462     
02463     
02464     ::HxCorba::ImageRep_ptr HxImageAsVec3Byte(::HxCorba::ImageRep_ptr img);
02465 
02466     
02467     
02468     
02469     ::HxCorba::ImageRep_ptr HxImageAsVec3Double(::HxCorba::ImageRep_ptr img);
02470 
02471     
02472     
02473     
02474     ::HxCorba::ImageRep_ptr HxImageAsVec3Float(::HxCorba::ImageRep_ptr img);
02475 
02476     
02477     
02478     
02479     ::HxCorba::ImageRep_ptr HxImageAsVec3Int(::HxCorba::ImageRep_ptr img);
02480 
02481     
02482     
02483     
02484     ::HxCorba::ImageRep_ptr HxImageAsVec3Short(::HxCorba::ImageRep_ptr img);
02485 
02486     
02487     
02488     
02489     ::HxCorba::ImageRep_ptr HxImageAsComplex(::HxCorba::ImageRep_ptr img);
02490 
02491     
02492     
02493     
02494     ::HxCorba::ImageRep_ptr HxColorSpace(::HxCorba::ImageRep_ptr im,
02495                                          ::HxCorba::ColorModel fromColorSpace,
02496                                          ::HxCorba::ColorModel toColorSpace);
02497 
02498     
02499     
02500     
02501     ::HxCorba::ImageRep_ptr HxAffinePix(::HxCorba::ImageRep_ptr im,
02502                                         const ::HxCorba::PixValue& v1,
02503                                         const ::HxCorba::PixValue& v2,
02504                                         const ::HxCorba::PixValue& v3);
02505 
02506     
02507     
02508     
02509     ::HxCorba::ImageRep_ptr HxRGB2Intensity(::HxCorba::ImageRep_ptr im);
02510 
02511     
02512     
02513     
02514     ::HxCorba::Histogram_ptr HxGreyEdgeHistogram(::HxCorba::ImageRep_ptr objImage,
02515                                                  CORBA::Double sigma,
02516                                                  CORBA::Double threshold);
02517 
02518     
02519     
02520     
02521     ::HxCorba::Histogram_ptr HxHistogramFromFile(const char* fileName);
02522 
02523     
02524     
02525     
02526     ::HxCorba::Histogram_ptr HxImageToHistogram(::HxCorba::ImageRep_ptr im,
02527                                                 CORBA::Long getDim,
02528                                                 CORBA::Double lowBin,
02529                                                 CORBA::Double highBin,
02530                                                 CORBA::Long nBin);
02531 
02532     
02533     
02534     
02535     ::HxCorba::Histogram_ptr HxImageToHistogramMask(::HxCorba::ImageRep_ptr im,
02536                                                     CORBA::Long getDim,
02537                                                     CORBA::Double lowBin,
02538                                                     CORBA::Double highBin,
02539                                                     CORBA::Long nBin,
02540                                                     ::HxCorba::ImageRep_ptr mask,
02541                                                     CORBA::Long maskVal);
02542 
02543     
02544     
02545     
02546     ::HxCorba::Blob2dSet* HxLabelBlobs(::HxCorba::ImageRep_ptr image,
02547                                        ::HxCorba::ImageRep_ptr mask,
02548                                        CORBA::Long minimalBlobArea);
02549 
02550     
02551     
02552     
02553     ::HxCorba::ImageRep_ptr HxHighlightRegion(::HxCorba::ImageRep_ptr im,
02554                                               ::HxCorba::ImageRep_ptr mask,
02555                                               CORBA::Long label,
02556                                               CORBA::Double factor);
02557 
02558     
02559     
02560     
02561     void HxExportMatlabPixels(::HxCorba::ImageRep_ptr im,
02562                               ::HxCorba::DoubleSeq& pixels);
02563 
02564     
02565     
02566     
02567     CORBA::Boolean HxWriteFile(::HxCorba::ImageRep_ptr im,
02568                                const char* fileName);
02569 
02570     
02571     
02572     
02573     CORBA::Boolean HxImagesToFile(const ::HxCorba::ImageList& ims,
02574                                   const char* fileName);
02575 
02576     
02577     
02578     
02579     ::HxCorba::ImageRep_ptr HxCannyEdgeMap(::HxCorba::ImageRep_ptr img,
02580                                            CORBA::Double sigma);
02581 
02582     
02583     
02584     
02585     ::HxCorba::ImageRep_ptr HxCannyThreshold(::HxCorba::ImageRep_ptr img,
02586                                              CORBA::Double sigma,
02587                                              CORBA::Double level);
02588 
02589     
02590     
02591     
02592     ::HxCorba::ImageRep_ptr HxCannyThresholdAlt(::HxCorba::ImageRep_ptr img,
02593                                                 CORBA::Double sigma,
02594                                                 CORBA::Double level);
02595 
02596     
02597     
02598     
02599     ::HxCorba::ImageRep_ptr HxCannyThresholdRec(::HxCorba::ImageRep_ptr img,
02600                                                 CORBA::Double sigma,
02601                                                 CORBA::Double level);
02602 
02603     
02604     
02605     
02606     ::HxCorba::ImageRep_ptr HxConvGauss2d(::HxCorba::ImageRep_ptr img,
02607                                           CORBA::Double sigmax,
02608                                           CORBA::Long orderDerivx,
02609                                           CORBA::Double accuracyx,
02610                                           CORBA::Double sigmay,
02611                                           CORBA::Long orderDerivy,
02612                                           CORBA::Double accuracyy);
02613 
02614     
02615     
02616     
02617     ::HxCorba::ImageRep_ptr HxConvGauss3d(::HxCorba::ImageRep_ptr img,
02618                                           CORBA::Double sigmax,
02619                                           CORBA::Long orderDerivx,
02620                                           CORBA::Double accuracyx,
02621                                           CORBA::Double sigmay,
02622                                           CORBA::Long orderDerivy,
02623                                           CORBA::Double accuracyy,
02624                                           CORBA::Double sigmaz,
02625                                           CORBA::Long orderDerivz,
02626                                           CORBA::Double accuracyz);
02627 
02628     
02629     
02630     
02631     ::HxCorba::ImageRep_ptr HxConvKernelSeparated(::HxCorba::ImageRep_ptr im,
02632                                                   ::HxCorba::ImageRep_ptr kernel,
02633                                                   ::HxCorba::ResultPrecision resPrec);
02634 
02635     
02636     
02637     
02638     ::HxCorba::ImageRep_ptr HxConvKernelSeparated2d(::HxCorba::ImageRep_ptr img,
02639                                                     ::HxCorba::ImageRep_ptr kernelX,
02640                                                     ::HxCorba::ImageRep_ptr kernelY,
02641                                                     ::HxCorba::ResultPrecision resPrec);
02642 
02643     
02644     
02645     
02646     ::HxCorba::ImageRep_ptr HxConvolution(::HxCorba::ImageRep_ptr im,
02647                                           ::HxCorba::ImageRep_ptr kernel,
02648                                           ::HxCorba::ResultPrecision resPrec);
02649 
02650     
02651     
02652     
02653     ::HxCorba::ImageRep_ptr HxDefuz(::HxCorba::ImageRep_ptr im,
02654                                     CORBA::Long windowSzX,
02655                                     CORBA::Long windowSzY,
02656                                     CORBA::Double thr);
02657 
02658     
02659     
02660     
02661     ::HxCorba::ImageRep_ptr HxDistanceTransform(::HxCorba::ImageRep_ptr img);
02662 
02663     
02664     
02665     
02666     ::HxCorba::ImageRep_ptr HxGauss(::HxCorba::ImageRep_ptr img,
02667                                     CORBA::Double sigma,
02668                                     CORBA::Double accuracy);
02669 
02670     
02671     
02672     
02673     ::HxCorba::ImageRep_ptr HxGaussDerivative2d(::HxCorba::ImageRep_ptr img,
02674                                                 CORBA::Double sigma,
02675                                                 CORBA::Long orderDerivx,
02676                                                 CORBA::Long orderDerivy,
02677                                                 CORBA::Double accuracy);
02678 
02679     
02680     
02681     
02682     ::HxCorba::ImageRep_ptr HxGaussDerivative3d(::HxCorba::ImageRep_ptr img,
02683                                                 CORBA::Double sigma,
02684                                                 CORBA::Long orderDerivx,
02685                                                 CORBA::Long orderDerivy,
02686                                                 CORBA::Long orderDerivz,
02687                                                 CORBA::Double accuracy);
02688 
02689     
02690     
02691     
02692     ::HxCorba::ImageRep_ptr HxGaussianDeblur(::HxCorba::ImageRep_ptr im,
02693                                              CORBA::Double dr,
02694                                              CORBA::Double dc);
02695 
02696     
02697     
02698     
02699     ::HxCorba::ImageRep_ptr HxKuwahara(::HxCorba::ImageRep_ptr im,
02700                                        CORBA::Long width,
02701                                        CORBA::Long height);
02702 
02703     
02704     
02705     
02706     ::HxCorba::ImageRep_ptr HxLocalMode(::HxCorba::ImageRep_ptr f,
02707                                         ::HxCorba::ImageRep_ptr g,
02708                                         CORBA::Long nr,
02709                                         CORBA::Double sigmax,
02710                                         CORBA::Double sigmay,
02711                                         CORBA::Double sigmaval,
02712                                         const ::HxCorba::Sizes& ngbSize);
02713 
02714     
02715     
02716     
02717     ::HxCorba::ImageRep_ptr HxNormalizedCorrelation(::HxCorba::ImageRep_ptr im,
02718                                                     ::HxCorba::ImageRep_ptr kernel);
02719 
02720     
02721     
02722     
02723     ::HxCorba::ImageRep_ptr HxPercentile(::HxCorba::ImageRep_ptr im,
02724                                          CORBA::Long neighSize,
02725                                          CORBA::Double perc);
02726 
02727     
02728     
02729     
02730     ::HxCorba::ImageRep_ptr HxRecGabor(::HxCorba::ImageRep_ptr im,
02731                                        CORBA::Double s,
02732                                        CORBA::Double omega0,
02733                                        CORBA::Double theta);
02734 
02735     
02736     
02737     
02738     ::HxCorba::ImageRep_ptr HxRecGauss(::HxCorba::ImageRep_ptr im,
02739                                        CORBA::Double sx,
02740                                        CORBA::Double sy,
02741                                        CORBA::Long dx,
02742                                        CORBA::Long dy,
02743                                        CORBA::Long recurOrder);
02744 
02745     
02746     
02747     
02748     ::HxCorba::ImageRep_ptr HxUniform(::HxCorba::ImageRep_ptr im,
02749                                       const ::HxCorba::Sizes& size);
02750 
02751     
02752     
02753     
02754     ::HxCorba::ImageRep_ptr HxUniformNonSep(::HxCorba::ImageRep_ptr im,
02755                                             const ::HxCorba::Sizes& size);
02756 
02757     
02758     
02759     
02760     ::HxCorba::ImageRep_ptr HxMakeFrom2Images(::HxCorba::ImageRep_ptr i1,
02761                                               ::HxCorba::ImageRep_ptr i2);
02762 
02763     
02764     
02765     
02766     ::HxCorba::ImageRep_ptr HxMakeFrom3Images(::HxCorba::ImageRep_ptr i1,
02767                                               ::HxCorba::ImageRep_ptr i2,
02768                                               ::HxCorba::ImageRep_ptr i3);
02769 
02770     
02771     
02772     
02773     ::HxCorba::ImageRep_ptr HxMakeFromByteData(CORBA::Long pixelDimensionality,
02774                                                CORBA::Long dimensions,
02775                                                const ::HxCorba::Sizes& size,
02776                                                const ::HxCorba::OctetSeq& data);
02777 
02778     
02779     
02780     
02781     ::HxCorba::ImageRep_ptr HxMakeFromDoubleData(CORBA::Long pixelDimensionality,
02782                                                  CORBA::Long dimensions,
02783                                                  const ::HxCorba::Sizes& size,
02784                                                  const ::HxCorba::DoubleSeq& data);
02785 
02786     
02787     
02788     
02789     ::HxCorba::ImageRep_ptr HxMakeFromFile(const char* fileName);
02790 
02791     
02792     
02793     
02794     ::HxCorba::ImageRep_ptr HxMakeFromFloatData(CORBA::Long pixelDimensionality,
02795                                                 CORBA::Long dimensions,
02796                                                 const ::HxCorba::Sizes& size,
02797                                                 const ::HxCorba::FloatSeq& data);
02798 
02799     
02800     
02801     
02802     ::HxCorba::ImageRep_ptr HxMakeFromGrayValue(::HxCorba::ImageSignature signature,
02803                                                 const ::HxCorba::Sizes& size,
02804                                                 const ::HxCorba::OctetSeq& pixels);
02805 
02806     
02807     
02808     
02809     ::HxCorba::ImageRep_ptr HxMakeFromImage(::HxCorba::ImageSignature signature,
02810                                             ::HxCorba::ImageRep_ptr src);
02811 
02812     
02813     
02814     
02815     ::HxCorba::ImageRep_ptr HxMakeFromImport(::HxCorba::ImageSignature signature,
02816                                              const ::HxCorba::Sizes& size,
02817                                              const char* importOp,
02818                                              ::HxCorba::TagList_ptr tags);
02819 
02820     
02821     
02822     
02823     ::HxCorba::ImageRep_ptr HxMakeFromIntData(CORBA::Long pixelDimensionality,
02824                                               CORBA::Long dimensions,
02825                                               const ::HxCorba::Sizes& size,
02826                                               const ::HxCorba::LongSeq& data);
02827 
02828     
02829     
02830     
02831     ::HxCorba::ImageRep_ptr HxMakeFromJavaRgb(::HxCorba::ImageSignature signature,
02832                                               const ::HxCorba::Sizes& size,
02833                                               const ::HxCorba::LongSeq& pixels);
02834 
02835     
02836     
02837     
02838     ::HxCorba::ImageRep_ptr HxMakeFromMatlab(::HxCorba::ImageSignature signature,
02839                                              const ::HxCorba::Sizes& size,
02840                                              const ::HxCorba::DoubleSeq& pixels);
02841 
02842     
02843     
02844     
02845     ::HxCorba::ImageRep_ptr HxMakeFromNamedGenerator(::HxCorba::ImageSignature signature,
02846                                                      const char* generatorName,
02847                                                      ::HxCorba::TagList_ptr tags);
02848 
02849     
02850     
02851     
02852     ::HxCorba::ImageRep_ptr HxMakeFromPpmPixels(::HxCorba::ImageSignature signature,
02853                                                 const ::HxCorba::Sizes& size,
02854                                                 const ::HxCorba::OctetSeq& pixels);
02855 
02856     
02857     
02858     
02859     ::HxCorba::ImageRep_ptr HxMakeFromShortData(CORBA::Long pixelDimensionality,
02860                                                 CORBA::Long dimensions,
02861                                                 const ::HxCorba::Sizes& size,
02862                                                 const ::HxCorba::ShortSeq& data);
02863 
02864     
02865     
02866     
02867     ::HxCorba::ImageRep_ptr HxMakeFromSignature(::HxCorba::ImageSignature signature,
02868                                                 const ::HxCorba::Sizes& size);
02869 
02870     
02871     
02872     
02873     ::HxCorba::ImageRep_ptr HxMakeFromValue(::HxCorba::ImageSignature signature,
02874                                             const ::HxCorba::Sizes& size,
02875                                             const ::HxCorba::PixValue& val);
02876 
02877     
02878     
02879     
02880     ::HxCorba::ImageRep_ptr HxMakeGaussian1d(CORBA::Double sigma,
02881                                              CORBA::Long deri,
02882                                              CORBA::Double accuracy,
02883                                              CORBA::Long maxfsize,
02884                                              CORBA::Long fsize);
02885 
02886     
02887     
02888     
02889     ::HxCorba::ImageRep_ptr HxMakeParabola1d(CORBA::Double rho,
02890                                              CORBA::Double accuracy,
02891                                              CORBA::Long maxfsize,
02892                                              CORBA::Long fsize);
02893 
02894     
02895     
02896     
02897     ::HxCorba::ImageList* HxImagesFromFile(const char* fileName);
02898 
02899     
02900     
02901     
02902     ::HxCorba::ImageRep_ptr HxExtend(::HxCorba::ImageRep_ptr img,
02903                                      ::HxCorba::ImageRep_ptr background,
02904                                      const ::HxCorba::Point& begin);
02905 
02906     
02907     
02908     
02909     ::HxCorba::ImageRep_ptr HxExtendVal(::HxCorba::ImageRep_ptr img,
02910                                         const ::HxCorba::Sizes& newSize,
02911                                         const ::HxCorba::PixValue& background,
02912                                         const ::HxCorba::Point& begin);
02913 
02914     
02915     
02916     
02917     ::HxCorba::ImageRep_ptr HxReflect(::HxCorba::ImageRep_ptr img,
02918                                       CORBA::Long doX,
02919                                       CORBA::Long doY,
02920                                       CORBA::Long doZ);
02921 
02922     
02923     
02924     
02925     ::HxCorba::ImageRep_ptr HxRestrict(::HxCorba::ImageRep_ptr img,
02926                                        const ::HxCorba::Point& begin,
02927                                        const ::HxCorba::Point& end);
02928 
02929     
02930     
02931     
02932     ::HxCorba::ImageRep_ptr HxRotate(::HxCorba::ImageRep_ptr img,
02933                                      CORBA::Double alpha,
02934                                      ::HxCorba::GeoIntType gi,
02935                                      CORBA::Long adjustSize,
02936                                      const ::HxCorba::PixValue& background);
02937 
02938     
02939     
02940     
02941     ::HxCorba::ImageRep_ptr HxScale(::HxCorba::ImageRep_ptr img,
02942                                     CORBA::Double sx,
02943                                     CORBA::Double sy,
02944                                     CORBA::Double sz,
02945                                     ::HxCorba::GeoIntType gi,
02946                                     CORBA::Long adjustSize);
02947 
02948     
02949     
02950     
02951     ::HxCorba::ImageRep_ptr HxTranslate(::HxCorba::ImageRep_ptr img,
02952                                         CORBA::Long sx,
02953                                         CORBA::Long sy,
02954                                         CORBA::Long sz);
02955 
02956     
02957     
02958     
02959     ::HxCorba::ImageRep_ptr HxTranspose(::HxCorba::ImageRep_ptr img);
02960 
02961     
02962     
02963     
02964     CORBA::Long HxImageMaxSize(::HxCorba::ImageRep_ptr img);
02965 
02966     
02967     
02968     
02969     CORBA::Long HxImageMinSize(::HxCorba::ImageRep_ptr img);
02970 
02971     
02972     
02973     
02974     ::HxCorba::PixValue HxIdentMaskMean(::HxCorba::ImageRep_ptr im,
02975                                         ::HxCorba::ImageRep_ptr mask,
02976                                         const ::HxCorba::Point& p,
02977                                         const ::HxCorba::Sizes& size,
02978                                         CORBA::Long label);
02979 
02980     
02981     
02982     
02983     ::HxCorba::PixValue HxIdentMaskMedian(::HxCorba::ImageRep_ptr im,
02984                                           ::HxCorba::ImageRep_ptr mask,
02985                                           const ::HxCorba::Point& p,
02986                                           const ::HxCorba::Sizes& size,
02987                                           CORBA::Long label);
02988 
02989     
02990     
02991     
02992     ::HxCorba::PixValue HxIdentMaskStDev(::HxCorba::ImageRep_ptr im,
02993                                          ::HxCorba::ImageRep_ptr mask,
02994                                          const ::HxCorba::Point& p,
02995                                          const ::HxCorba::Sizes& size,
02996                                          CORBA::Long label);
02997 
02998     
02999     
03000     
03001     ::HxCorba::PixValue HxIdentMaskSum(::HxCorba::ImageRep_ptr im,
03002                                        ::HxCorba::ImageRep_ptr mask,
03003                                        const ::HxCorba::Point& p,
03004                                        const ::HxCorba::Sizes& size,
03005                                        CORBA::Long label);
03006 
03007     
03008     
03009     
03010     ::HxCorba::PixValue HxIdentMaskVariance(::HxCorba::ImageRep_ptr im,
03011                                             ::HxCorba::ImageRep_ptr mask,
03012                                             const ::HxCorba::Point& p,
03013                                             const ::HxCorba::Sizes& size,
03014                                             CORBA::Long label);
03015 
03016     
03017     
03018     
03019     ::HxCorba::PixValue HxWeightMaskSum(::HxCorba::ImageRep_ptr im,
03020                                         ::HxCorba::ImageRep_ptr mask,
03021                                         const ::HxCorba::Point& p);
03022 
03023     
03024     
03025     
03026     ::HxCorba::ImageRep_ptr HxAreaClosing(::HxCorba::ImageRep_ptr im,
03027                                           CORBA::Long conn,
03028                                           CORBA::Long minarea);
03029 
03030     
03031     
03032     
03033     ::HxCorba::ImageRep_ptr HxAreaOpening(::HxCorba::ImageRep_ptr im,
03034                                           CORBA::Long conn,
03035                                           CORBA::Long area);
03036 
03037     
03038     
03039     
03040     ::HxCorba::ImageRep_ptr HxClosing(::HxCorba::ImageRep_ptr im,
03041                                       ::HxCorba::SF_ptr s);
03042 
03043     
03044     
03045     
03046     ::HxCorba::ImageRep_ptr HxClosingByReconstruction(::HxCorba::ImageRep_ptr im,
03047                                                       ::HxCorba::SF_ptr s1,
03048                                                       ::HxCorba::SF_ptr s2);
03049 
03050     
03051     
03052     
03053     ::HxCorba::ImageRep_ptr HxClosingByReconstructionTopHat(::HxCorba::ImageRep_ptr im,
03054                                                             ::HxCorba::SF_ptr s1,
03055                                                             ::HxCorba::SF_ptr s2);
03056 
03057     
03058     
03059     
03060     ::HxCorba::ImageRep_ptr HxClosingTopHat(::HxCorba::ImageRep_ptr im,
03061                                             ::HxCorba::SF_ptr s);
03062 
03063     
03064     
03065     
03066     ::HxCorba::ImageRep_ptr HxConditionalDilation(::HxCorba::ImageRep_ptr im,
03067                                                   ::HxCorba::ImageRep_ptr mask,
03068                                                   ::HxCorba::SF_ptr s,
03069                                                   CORBA::Long nrIter);
03070 
03071     
03072     
03073     
03074     ::HxCorba::ImageRep_ptr HxConditionalErosion(::HxCorba::ImageRep_ptr im,
03075                                                  ::HxCorba::ImageRep_ptr mask,
03076                                                  ::HxCorba::SF_ptr s,
03077                                                  CORBA::Long nrIter);
03078 
03079     
03080     
03081     
03082     ::HxCorba::ImageRep_ptr HxDilation(::HxCorba::ImageRep_ptr im,
03083                                        ::HxCorba::SF_ptr s);
03084 
03085     
03086     
03087     
03088     ::HxCorba::ImageRep_ptr HxDistanceTransformMM(::HxCorba::ImageRep_ptr im,
03089                                                   ::HxCorba::SF_ptr s);
03090 
03091     
03092     
03093     
03094     ::HxCorba::ImageRep_ptr HxErosion(::HxCorba::ImageRep_ptr im,
03095                                       ::HxCorba::SF_ptr s);
03096 
03097     
03098     
03099     
03100     ::HxCorba::ImageRep_ptr HxGeodesicDistanceTransform(::HxCorba::ImageRep_ptr im,
03101                                                         CORBA::Long conn);
03102 
03103     
03104     
03105     
03106     ::HxCorba::ImageRep_ptr HxHilditchSkeleton(::HxCorba::ImageRep_ptr im);
03107 
03108     
03109     
03110     
03111     ::HxCorba::ImageRep_ptr HxHitOrMiss(::HxCorba::ImageRep_ptr im,
03112                                         ::HxCorba::SF_ptr s1,
03113                                         ::HxCorba::SF_ptr s2);
03114 
03115     
03116     
03117     
03118     ::HxCorba::ImageRep_ptr HxInfimumReconstruction(::HxCorba::ImageRep_ptr im,
03119                                                     ::HxCorba::ImageRep_ptr mask,
03120                                                     ::HxCorba::SF_ptr s);
03121 
03122     
03123     
03124     
03125     ::HxCorba::ImageRep_ptr HxMorphologicalContour(::HxCorba::ImageRep_ptr im,
03126                                                    ::HxCorba::SF_ptr s);
03127 
03128     
03129     
03130     
03131     ::HxCorba::ImageRep_ptr HxMorphologicalGradient(::HxCorba::ImageRep_ptr im,
03132                                                     ::HxCorba::SF_ptr s);
03133 
03134     
03135     
03136     
03137     ::HxCorba::ImageRep_ptr HxMorphologicalGradient2(::HxCorba::ImageRep_ptr im,
03138                                                      ::HxCorba::SF_ptr s1,
03139                                                      ::HxCorba::SF_ptr s2);
03140 
03141     
03142     
03143     
03144     ::HxCorba::ImageRep_ptr HxOpening(::HxCorba::ImageRep_ptr im,
03145                                       ::HxCorba::SF_ptr s);
03146 
03147     
03148     
03149     
03150     ::HxCorba::ImageRep_ptr HxOpeningByReconstruction(::HxCorba::ImageRep_ptr im,
03151                                                       ::HxCorba::SF_ptr s1,
03152                                                       ::HxCorba::SF_ptr s2);
03153 
03154     
03155     
03156     
03157     ::HxCorba::ImageRep_ptr HxOpeningByReconstructionTopHat(::HxCorba::ImageRep_ptr im,
03158                                                             ::HxCorba::SF_ptr s1,
03159                                                             ::HxCorba::SF_ptr s2);
03160 
03161     
03162     
03163     
03164     ::HxCorba::ImageRep_ptr HxOpeningTopHat(::HxCorba::ImageRep_ptr im,
03165                                             ::HxCorba::SF_ptr s);
03166 
03167     
03168     
03169     
03170     ::HxCorba::ImageRep_ptr HxParabolicDilation(::HxCorba::ImageRep_ptr img,
03171                                                 CORBA::Double rho,
03172                                                 CORBA::Double accuracy);
03173 
03174     
03175     
03176     
03177     ::HxCorba::ImageRep_ptr HxParabolicErosion(::HxCorba::ImageRep_ptr img,
03178                                                CORBA::Double rho,
03179                                                CORBA::Double accuracy);
03180 
03181     
03182     
03183     
03184     ::HxCorba::ImageRep_ptr HxPeakRemoval(::HxCorba::ImageRep_ptr im,
03185                                           CORBA::Long conn,
03186                                           CORBA::Long minarea);
03187 
03188     
03189     
03190     
03191     ::HxCorba::ImageRep_ptr HxRegionalMaxima(::HxCorba::ImageRep_ptr im,
03192                                              CORBA::Long conn);
03193 
03194     
03195     
03196     
03197     ::HxCorba::ImageRep_ptr HxRegionalMinima(::HxCorba::ImageRep_ptr im,
03198                                              CORBA::Long conn);
03199 
03200     
03201     
03202     
03203     ::HxCorba::ImageRep_ptr HxSKIZ(::HxCorba::ImageRep_ptr im,
03204                                    CORBA::Long conn);
03205 
03206     
03207     
03208     
03209     ::HxCorba::ImageRep_ptr HxSkeleton(::HxCorba::ImageRep_ptr im,
03210                                        ::HxCorba::SF_ptr s);
03211 
03212     
03213     
03214     
03215     ::HxCorba::ImageRep_ptr HxSupremumReconstruction(::HxCorba::ImageRep_ptr im,
03216                                                      ::HxCorba::ImageRep_ptr mask,
03217                                                      ::HxCorba::SF_ptr s);
03218 
03219     
03220     
03221     
03222     ::HxCorba::ImageRep_ptr HxThickening(::HxCorba::ImageRep_ptr im,
03223                                          ::HxCorba::SF_ptr s1,
03224                                          ::HxCorba::SF_ptr s2);
03225 
03226     
03227     
03228     
03229     ::HxCorba::ImageRep_ptr HxThinning(::HxCorba::ImageRep_ptr im,
03230                                        ::HxCorba::SF_ptr s1,
03231                                        ::HxCorba::SF_ptr s2);
03232 
03233     
03234     
03235     
03236     ::HxCorba::ImageRep_ptr HxValleyRemoval(::HxCorba::ImageRep_ptr im,
03237                                             CORBA::Long conn,
03238                                             CORBA::Long minarea);
03239 
03240     
03241     
03242     
03243     ::HxCorba::ImageRep_ptr HxWatershed(::HxCorba::ImageRep_ptr im,
03244                                         CORBA::Long conn);
03245 
03246     
03247     
03248     
03249     ::HxCorba::ImageRep_ptr HxWatershedMarkers(::HxCorba::ImageRep_ptr input,
03250                                                ::HxCorba::ImageRep_ptr mask,
03251                                                CORBA::Long conn,
03252                                                CORBA::Boolean doLabelMask);
03253 
03254     
03255     
03256     
03257     ::HxCorba::ImageRep_ptr HxWatershedMarkers2(::HxCorba::ImageRep_ptr input,
03258                                                 ::HxCorba::ImageRep_ptr mask,
03259                                                 CORBA::Long conn,
03260                                                 CORBA::Boolean doLabelMask,
03261                                                 CORBA::Long costMethod);
03262 
03263     
03264     
03265     
03266     ::HxCorba::ImageRep_ptr HxWatershedSlow(::HxCorba::ImageRep_ptr im,
03267                                             ::HxCorba::SF_ptr s,
03268                                             const char* linereg);
03269 
03270     
03271     
03272     
03273     ::HxCorba::ImageRep_ptr HxDisplayOF(::HxCorba::ImageRep_ptr im,
03274                                         CORBA::Long scale_x,
03275                                         CORBA::Long scale_y,
03276                                         CORBA::Double mul_x,
03277                                         CORBA::Double mul_y,
03278                                         CORBA::Long pixelsize);
03279 
03280     
03281     
03282     
03283     ::HxCorba::ImageRep_ptr HxOpticalFlow(::HxCorba::ImageRep_ptr im1,
03284                                           ::HxCorba::ImageRep_ptr im2);
03285 
03286     
03287     
03288     
03289     ::HxCorba::ImageRep_ptr HxOpticalFlowMultiScale(::HxCorba::ImageRep_ptr im1,
03290                                                     ::HxCorba::ImageRep_ptr im2);
03291 
03292     
03293     
03294     
03295     ::HxCorba::ImageRep_ptr HxAddBinaryNoise(::HxCorba::ImageRep_ptr im,
03296                                              CORBA::Double percent);
03297 
03298     
03299     
03300     
03301     ::HxCorba::ImageRep_ptr HxAddGaussianNoise(::HxCorba::ImageRep_ptr im,
03302                                                CORBA::Double mean,
03303                                                CORBA::Double stdev);
03304 
03305     
03306     
03307     
03308     ::HxCorba::ImageRep_ptr HxAddPoissonNoise(::HxCorba::ImageRep_ptr im,
03309                                               CORBA::Double conversionFactor);
03310 
03311     
03312     
03313     
03314     ::HxCorba::ImageRep_ptr HxAddUniformNoise(::HxCorba::ImageRep_ptr im);
03315 
03316     
03317     
03318     
03319     ::HxCorba::ImageRep_ptr HxContrastStretch(::HxCorba::ImageRep_ptr im,
03320                                               CORBA::Double val);
03321 
03322     
03323     
03324     
03325     ::HxCorba::ImageRep_ptr HxSetBorderValue(::HxCorba::ImageRep_ptr im,
03326                                              CORBA::Long w,
03327                                              CORBA::Long h,
03328                                              const ::HxCorba::PixValue& val);
03329 
03330     
03331     
03332     
03333     ::HxCorba::ImageRep_ptr HxSetPartImage(::HxCorba::ImageRep_ptr im,
03334                                            CORBA::Long x1,
03335                                            CORBA::Long y1,
03336                                            CORBA::Long x2,
03337                                            CORBA::Long y2,
03338                                            const ::HxCorba::PixValue& val);
03339 
03340     
03341     
03342     
03343     ::HxCorba::ImageRep_ptr HxSquaredDistance(::HxCorba::ImageRep_ptr im1,
03344                                               ::HxCorba::ImageRep_ptr im2);
03345 
03346     
03347     
03348     
03349     ::HxCorba::ImageRep_ptr HxBernsenThreshold(::HxCorba::ImageRep_ptr im,
03350                                                CORBA::Long windowSz,
03351                                                CORBA::Long uniformTh,
03352                                                CORBA::Boolean uniformLow);
03353 
03354     
03355     
03356     
03357     ::HxCorba::ImageRep_ptr HxColorGaborSegmentation(::HxCorba::ImageRep_ptr im,
03358                                                      ::HxCorba::ColorGaborSegmentationAlgorithm segAlg,
03359                                                      ::HxCorba::ColorGaborSegmentationInvariant invariantType,
03360                                                      CORBA::Double minRegionFraction,
03361                                                      CORBA::Double threshold);
03362 
03363     
03364     
03365     
03366     ::HxCorba::ImageRep_ptr HxEntropyThreshold(::HxCorba::ImageRep_ptr im);
03367 
03368     
03369     
03370     
03371     ::HxCorba::ImageRep_ptr HxIsodataThreshold(::HxCorba::ImageRep_ptr im);
03372 
03373     
03374     
03375     
03376     ::HxCorba::ImageRep_ptr HxLabel(::HxCorba::ImageRep_ptr im,
03377                                     CORBA::Long conn);
03378 
03379     
03380     
03381     
03382     ::HxCorba::ImageRep_ptr HxLabel2(::HxCorba::ImageRep_ptr im,
03383                                      CORBA::Long conn);
03384 
03385     
03386     
03387     
03388     ::HxCorba::ImageRep_ptr HxThreshold(::HxCorba::ImageRep_ptr im,
03389                                         const ::HxCorba::PixValue& val);
03390 
03391     
03392     
03393     
03394     ::HxCorba::ImageRep_ptr HxTriStateThreshold(::HxCorba::ImageRep_ptr im,
03395                                                 const ::HxCorba::PixValue& level,
03396                                                 const ::HxCorba::PixValue& v1,
03397                                                 const ::HxCorba::PixValue& v2,
03398                                                 const ::HxCorba::PixValue& v3);
03399 
03400     
03401     
03402     
03403     CORBA::Boolean VxRelEquals(const ::HxCorba::VxTimeSpan& elt1,
03404                                const ::HxCorba::VxTimeSpan& elt2);
03405 
03406     
03407     
03408     
03409     CORBA::Boolean VxRelMeets(const ::HxCorba::VxTimeSpan& elt1,
03410                               const ::HxCorba::VxTimeSpan& elt2);
03411 
03412     
03413     
03414     
03415     CORBA::Boolean VxRelBefore(const ::HxCorba::VxTimeSpan& elt1,
03416                                const ::HxCorba::VxTimeSpan& elt2);
03417 
03418     
03419     
03420     
03421     CORBA::Boolean VxRelOverlaps(const ::HxCorba::VxTimeSpan& elt1,
03422                                  const ::HxCorba::VxTimeSpan& elt2);
03423 
03424     
03425     
03426     
03427     CORBA::Boolean VxRelDur(const ::HxCorba::VxTimeSpan& elt1,
03428                             const ::HxCorba::VxTimeSpan& elt2);
03429 
03430     
03431     
03432     
03433     CORBA::Boolean VxRelCon(const ::HxCorba::VxTimeSpan& elt1,
03434                             const ::HxCorba::VxTimeSpan& elt2);
03435 
03436     
03437     
03438     
03439     CORBA::Boolean VxRelMeetsAnywhere(const ::HxCorba::VxTimeSpan& elt1,
03440                                       const ::HxCorba::VxTimeSpan& elt2);
03441 
03442     
03443     
03444     
03445     CORBA::Boolean VxRelBeforeAfter(const ::HxCorba::VxTimeSpan& elt1,
03446                                     const ::HxCorba::VxTimeSpan& elt2);
03447 
03448     
03449     
03450     
03451     CORBA::Boolean VxRelOverlapsAnywhere(const ::HxCorba::VxTimeSpan& elt1,
03452                                          const ::HxCorba::VxTimeSpan& elt2);
03453 
03454     
03455     
03456     
03457     char* VxRelAsString(const ::HxCorba::VxTimeSpan& elt1,
03458                         const ::HxCorba::VxTimeSpan& elt2);
03459 
03460     
03461     
03462     
03463     void HxIDBOpen(const char* name,
03464                    const char* indexFile);
03465 
03466     
03467     
03468     
03469     ::HxCorba::StringSeq* HxIDBRandom(const char* name,
03470                                       CORBA::Long n);
03471 
03472     
03473     
03474     
03475     ::HxCorba::StringSeq* HxIDBSearch(const char* key,
03476                                       const char* name,
03477                                       CORBA::Long n);
03478 
03479     
03480     
03481     
03482     void HxInvarOpenDB(const char* indexFile,
03483                        const char* dbDir);
03484 
03485     
03486     
03487     
03488     ::HxCorba::StringSeq* HxInvarRandom(const char* invar,
03489                                         CORBA::Long n);
03490 
03491     
03492     
03493     
03494     ::HxCorba::StringSeq* HxInvarSearch(::HxCorba::ImageRep_ptr im,
03495                                         const char* invar,
03496                                         CORBA::Long n);
03497 
03498     
03499     
03500     
03501     ::HxCorba::StringSeq* HxInvarSearchHisto(const ::HxCorba::HistogramList& target,
03502                                              const char* invar,
03503                                              CORBA::Long n);
03504 
03505     
03506     
03507     
03508     CORBA::Double HxInvarMatchHistos(const ::HxCorba::HistogramList& l1,
03509                                      const ::HxCorba::HistogramList& l2);
03510 
03511     
03512     
03513     
03514     void HxInvarIndexDB(const char* indexFile,
03515                         const char* dbDir,
03516                         const char* invar,
03517                         CORBA::Double s,
03518                         CORBA::Long bins);
03519 
03520     
03521     
03522     
03523     CORBA::Long HxInvarDBSize(const char* invar);
03524 
03525     
03526     
03527     
03528     CORBA::Long HxInvarBinsPerHistogram(const char* invar);
03529 
03530     
03531     
03532     
03533     CORBA::Long HxInvarChannels(const char* invar);
03534 
03535     
03536     
03537     
03538     ::HxCorba::StringSeq* HxInvarDBList(const char* invar);
03539 
03540     
03541     
03542     
03543     ::HxCorba::FloatSeq* HxInvarGetHistos(const char* invar,
03544                                           const char* key);
03545 
03546     
03547     
03548     
03549     ::HxCorba::StringSeq* HxInvarSearchKey(const char* key,
03550                                            const char* invar,
03551                                            CORBA::Long n);
03552 
03553     
03554     
03555     
03556     ::HxCorba::DoubleSeq* HxInvarScores(const char* invar,
03557                                         CORBA::Long n);
03558 
03559     
03560     
03561     
03562     ::HxCorba::ImageRep_ptr HxNJetInvarE(::HxCorba::NJet_ptr nj);
03563 
03564     
03565     
03566     
03567     ::HxCorba::ImageRep_ptr HxNJetInvarC(::HxCorba::NJet_ptr nj);
03568 
03569     
03570     
03571     
03572     ::HxCorba::ImageRep_ptr HxNJetInvarWw(::HxCorba::NJet_ptr nj);
03573 
03574     
03575     
03576     
03577     ::HxCorba::ImageRep_ptr HxNJetInvarCw(::HxCorba::NJet_ptr nj);
03578 
03579     
03580     
03581     
03582     ::HxCorba::HistogramList* HxNJetInvarEHisto(::HxCorba::NJet_ptr nj,
03583                                                 CORBA::Long nBin);
03584 
03585     
03586     
03587     
03588     ::HxCorba::HistogramList* HxNJetInvarCHisto(::HxCorba::NJet_ptr nj,
03589                                                 CORBA::Long nBin);
03590 
03591     
03592     
03593     
03594     ::HxCorba::HistogramList* HxNJetInvarWwHisto(::HxCorba::NJet_ptr nj,
03595                                                  CORBA::Long nBin);
03596 
03597     
03598     
03599     
03600     ::HxCorba::HistogramList* HxNJetInvarCwHisto(::HxCorba::NJet_ptr nj,
03601                                                  CORBA::Long nBin);
03602 
03603     
03604     
03605     
03606     ::HxCorba::HistogramList* HxInvarEHisto(::HxCorba::ImageRep_ptr im,
03607                                             CORBA::Double scale,
03608                                             CORBA::Long nBin);
03609 
03610     
03611     
03612     
03613     ::HxCorba::HistogramList* HxInvarCHisto(::HxCorba::ImageRep_ptr im,
03614                                             CORBA::Double scale,
03615                                             CORBA::Long nBin);
03616 
03617     
03618     
03619     
03620     ::HxCorba::HistogramList* HxInvarWwHisto(::HxCorba::ImageRep_ptr im,
03621                                              CORBA::Double scale,
03622                                              CORBA::Long nBin);
03623 
03624     
03625     
03626     
03627     ::HxCorba::HistogramList* HxInvarCwHisto(::HxCorba::ImageRep_ptr im,
03628                                              CORBA::Double scale,
03629                                              CORBA::Long nBin);
03630 
03631     
03632     
03633     
03634     ::HxCorba::DoubleSeqSeq* HxNJetInvar(::HxCorba::ImageRep_ptr im,
03635                                          const char* invar,
03636                                          CORBA::Double scale,
03637                                          CORBA::Long nBin);
03638 
03639     
03640     
03641     
03642     ::HxCorba::ImageRep_ptr HxColorInvarEw(::HxCorba::ImageRep_ptr im,
03643                                            CORBA::Double scale);
03644 
03645     
03646     
03647     
03648     ::HxCorba::ImageRep_ptr HxColorInvarWw(::HxCorba::ImageRep_ptr im,
03649                                            CORBA::Double scale);
03650 
03651     
03652     
03653     
03654     ::HxCorba::ImageRep_ptr HxColorInvarCw(::HxCorba::ImageRep_ptr im,
03655                                            CORBA::Double scale);
03656 
03657     
03658     
03659     
03660     ::HxCorba::ImageRep_ptr HxColorInvarNw(::HxCorba::ImageRep_ptr im,
03661                                            CORBA::Double scale);
03662 
03663     
03664     
03665     
03666     ::HxCorba::ImageRep_ptr HxColorInvarHw(::HxCorba::ImageRep_ptr im,
03667                                            CORBA::Double scale);
03668 };
03669 
03670 } 
03671 
03672 
03673 
03674 
03675 namespace OBStubImpl_HxCorba
03676 {
03677 
03678 
03679 
03680 
03681 class GlobalOps : virtual public OBStubImpl_HxCorba::UserOps
03682 {
03683     GlobalOps(const GlobalOps&);
03684     void operator=(const GlobalOps&);
03685 
03686 protected:
03687 
03688     GlobalOps() { }
03689 
03690 public:
03691 
03692     static inline GlobalOps_ptr
03693     _duplicate(GlobalOps_ptr p)
03694     {
03695         if(p)
03696             p -> _OB_incRef();
03697         return p;
03698     }
03699 
03700     static inline GlobalOps_ptr
03701     _nil()
03702     {
03703         return 0;
03704     }
03705 
03706     
03707     
03708     
03709     virtual ::HxCorba::ImageRep_ptr HxAbs(::HxCorba::ImageRep_ptr im) = 0;
03710 
03711     
03712     
03713     
03714     virtual ::HxCorba::ImageRep_ptr HxCeil(::HxCorba::ImageRep_ptr im) = 0;
03715 
03716     
03717     
03718     
03719     virtual ::HxCorba::ImageRep_ptr HxComplement(::HxCorba::ImageRep_ptr im) = 0;
03720 
03721     
03722     
03723     
03724     virtual ::HxCorba::ImageRep_ptr HxExp(::HxCorba::ImageRep_ptr im) = 0;
03725 
03726     
03727     
03728     
03729     virtual ::HxCorba::ImageRep_ptr HxFloor(::HxCorba::ImageRep_ptr im) = 0;
03730 
03731     
03732     
03733     
03734     virtual ::HxCorba::ImageRep_ptr HxLog(::HxCorba::ImageRep_ptr im) = 0;
03735 
03736     
03737     
03738     
03739     virtual ::HxCorba::ImageRep_ptr HxLog10(::HxCorba::ImageRep_ptr im) = 0;
03740 
03741     
03742     
03743     
03744     virtual ::HxCorba::ImageRep_ptr HxNegate(::HxCorba::ImageRep_ptr im) = 0;
03745 
03746     
03747     
03748     
03749     virtual ::HxCorba::ImageRep_ptr HxNorm1(::HxCorba::ImageRep_ptr im) = 0;
03750 
03751     
03752     
03753     
03754     virtual ::HxCorba::ImageRep_ptr HxNorm2(::HxCorba::ImageRep_ptr im) = 0;
03755 
03756     
03757     
03758     
03759     virtual ::HxCorba::ImageRep_ptr HxNormInf(::HxCorba::ImageRep_ptr im) = 0;
03760 
03761     
03762     
03763     
03764     virtual ::HxCorba::ImageRep_ptr HxProjectRange(::HxCorba::ImageRep_ptr im,
03765                                                    CORBA::Long dimension) = 0;
03766 
03767     
03768     
03769     
03770     virtual ::HxCorba::ImageRep_ptr HxReciprocal(::HxCorba::ImageRep_ptr im) = 0;
03771 
03772     
03773     
03774     
03775     virtual ::HxCorba::ImageRep_ptr HxSqrt(::HxCorba::ImageRep_ptr im) = 0;
03776 
03777     
03778     
03779     
03780     virtual ::HxCorba::ImageRep_ptr HxRound(::HxCorba::ImageRep_ptr im) = 0;
03781 
03782     
03783     
03784     
03785     virtual ::HxCorba::ImageRep_ptr HxUnaryMax(::HxCorba::ImageRep_ptr im) = 0;
03786 
03787     
03788     
03789     
03790     virtual ::HxCorba::ImageRep_ptr HxUnaryMin(::HxCorba::ImageRep_ptr im) = 0;
03791 
03792     
03793     
03794     
03795     virtual ::HxCorba::ImageRep_ptr HxUnaryProduct(::HxCorba::ImageRep_ptr im) = 0;
03796 
03797     
03798     
03799     
03800     virtual ::HxCorba::ImageRep_ptr HxUnarySum(::HxCorba::ImageRep_ptr im) = 0;
03801 
03802     
03803     
03804     
03805     virtual ::HxCorba::ImageRep_ptr HxAcos(::HxCorba::ImageRep_ptr im) = 0;
03806 
03807     
03808     
03809     
03810     virtual ::HxCorba::ImageRep_ptr HxAsin(::HxCorba::ImageRep_ptr im) = 0;
03811 
03812     
03813     
03814     
03815     virtual ::HxCorba::ImageRep_ptr HxAtan(::HxCorba::ImageRep_ptr im) = 0;
03816 
03817     
03818     
03819     
03820     virtual ::HxCorba::ImageRep_ptr HxAtan2(::HxCorba::ImageRep_ptr im) = 0;
03821 
03822     
03823     
03824     
03825     virtual ::HxCorba::ImageRep_ptr HxCos(::HxCorba::ImageRep_ptr im) = 0;
03826 
03827     
03828     
03829     
03830     virtual ::HxCorba::ImageRep_ptr HxCosh(::HxCorba::ImageRep_ptr im) = 0;
03831 
03832     
03833     
03834     
03835     virtual ::HxCorba::ImageRep_ptr HxSin(::HxCorba::ImageRep_ptr im) = 0;
03836 
03837     
03838     
03839     
03840     virtual ::HxCorba::ImageRep_ptr HxSinh(::HxCorba::ImageRep_ptr im) = 0;
03841 
03842     
03843     
03844     
03845     virtual ::HxCorba::ImageRep_ptr HxTan(::HxCorba::ImageRep_ptr im) = 0;
03846 
03847     
03848     
03849     
03850     virtual ::HxCorba::ImageRep_ptr HxTanh(::HxCorba::ImageRep_ptr im) = 0;
03851 
03852     
03853     
03854     
03855     virtual ::HxCorba::ImageRep_ptr HxArg(::HxCorba::ImageRep_ptr im) = 0;
03856 
03857     
03858     
03859     
03860     virtual ::HxCorba::ImageRep_ptr HxConjugate(::HxCorba::ImageRep_ptr im) = 0;
03861 
03862     
03863     
03864     
03865     virtual ::HxCorba::ImageRep_ptr HxAdd(::HxCorba::ImageRep_ptr im1,
03866                                           ::HxCorba::ImageRep_ptr im2) = 0;
03867 
03868     
03869     
03870     
03871     virtual ::HxCorba::ImageRep_ptr HxAddSat(::HxCorba::ImageRep_ptr im1,
03872                                              ::HxCorba::ImageRep_ptr im2) = 0;
03873 
03874     
03875     
03876     
03877     virtual ::HxCorba::ImageRep_ptr HxAnd(::HxCorba::ImageRep_ptr im1,
03878                                           ::HxCorba::ImageRep_ptr im2) = 0;
03879 
03880     
03881     
03882     
03883     virtual ::HxCorba::ImageRep_ptr HxCross(::HxCorba::ImageRep_ptr im1,
03884                                             ::HxCorba::ImageRep_ptr im2) = 0;
03885 
03886     
03887     
03888     
03889     virtual ::HxCorba::ImageRep_ptr HxDiv(::HxCorba::ImageRep_ptr im1,
03890                                           ::HxCorba::ImageRep_ptr im2) = 0;
03891 
03892     
03893     
03894     
03895     virtual ::HxCorba::ImageRep_ptr HxDot(::HxCorba::ImageRep_ptr im1,
03896                                           ::HxCorba::ImageRep_ptr im2) = 0;
03897 
03898     
03899     
03900     
03901     virtual ::HxCorba::ImageRep_ptr HxEqual(::HxCorba::ImageRep_ptr im1,
03902                                             ::HxCorba::ImageRep_ptr im2) = 0;
03903 
03904     
03905     
03906     
03907     virtual ::HxCorba::ImageRep_ptr HxGreaterEqual(::HxCorba::ImageRep_ptr im1,
03908                                                    ::HxCorba::ImageRep_ptr im2) = 0;
03909 
03910     
03911     
03912     
03913     virtual ::HxCorba::ImageRep_ptr HxGreaterThan(::HxCorba::ImageRep_ptr im1,
03914                                                   ::HxCorba::ImageRep_ptr im2) = 0;
03915 
03916     
03917     
03918     
03919     virtual ::HxCorba::ImageRep_ptr HxInf(::HxCorba::ImageRep_ptr im1,
03920                                           ::HxCorba::ImageRep_ptr im2) = 0;
03921 
03922     
03923     
03924     
03925     virtual ::HxCorba::ImageRep_ptr HxInverseProjectRange(::HxCorba::ImageRep_ptr im1,
03926                                                           CORBA::Long dimension,
03927                                                           ::HxCorba::ImageRep_ptr im2) = 0;
03928 
03929     
03930     
03931     
03932     virtual ::HxCorba::ImageRep_ptr HxLeftShift(::HxCorba::ImageRep_ptr im1,
03933                                                 ::HxCorba::ImageRep_ptr im2) = 0;
03934 
03935     
03936     
03937     
03938     virtual ::HxCorba::ImageRep_ptr HxLessEqual(::HxCorba::ImageRep_ptr im1,
03939                                                 ::HxCorba::ImageRep_ptr im2) = 0;
03940 
03941     
03942     
03943     
03944     virtual ::HxCorba::ImageRep_ptr HxLessThan(::HxCorba::ImageRep_ptr im1,
03945                                                ::HxCorba::ImageRep_ptr im2) = 0;
03946 
03947     
03948     
03949     
03950     virtual ::HxCorba::ImageRep_ptr HxMax(::HxCorba::ImageRep_ptr im1,
03951                                           ::HxCorba::ImageRep_ptr im2) = 0;
03952 
03953     
03954     
03955     
03956     virtual ::HxCorba::ImageRep_ptr HxMin(::HxCorba::ImageRep_ptr im1,
03957                                           ::HxCorba::ImageRep_ptr im2) = 0;
03958 
03959     
03960     
03961     
03962     virtual ::HxCorba::ImageRep_ptr HxMod(::HxCorba::ImageRep_ptr im1,
03963                                           ::HxCorba::ImageRep_ptr im2) = 0;
03964 
03965     
03966     
03967     
03968     virtual ::HxCorba::ImageRep_ptr HxMul(::HxCorba::ImageRep_ptr im1,
03969                                           ::HxCorba::ImageRep_ptr im2) = 0;
03970 
03971     
03972     
03973     
03974     virtual ::HxCorba::ImageRep_ptr HxNotEqual(::HxCorba::ImageRep_ptr im1,
03975                                                ::HxCorba::ImageRep_ptr im2) = 0;
03976 
03977     
03978     
03979     
03980     virtual ::HxCorba::ImageRep_ptr HxOr(::HxCorba::ImageRep_ptr im1,
03981                                          ::HxCorba::ImageRep_ptr im2) = 0;
03982 
03983     
03984     
03985     
03986     virtual ::HxCorba::ImageRep_ptr HxPow(::HxCorba::ImageRep_ptr im1,
03987                                           ::HxCorba::ImageRep_ptr im2) = 0;
03988 
03989     
03990     
03991     
03992     virtual ::HxCorba::ImageRep_ptr HxRightShift(::HxCorba::ImageRep_ptr im1,
03993                                                  ::HxCorba::ImageRep_ptr im2) = 0;
03994 
03995     
03996     
03997     
03998     virtual ::HxCorba::ImageRep_ptr HxSub(::HxCorba::ImageRep_ptr im1,
03999                                           ::HxCorba::ImageRep_ptr im2) = 0;
04000 
04001     
04002     
04003     
04004     virtual ::HxCorba::ImageRep_ptr HxSubSat(::HxCorba::ImageRep_ptr im1,
04005                                              ::HxCorba::ImageRep_ptr im2) = 0;
04006 
04007     
04008     
04009     
04010     virtual ::HxCorba::ImageRep_ptr HxSup(::HxCorba::ImageRep_ptr im1,
04011                                           ::HxCorba::ImageRep_ptr im2) = 0;
04012 
04013     
04014     
04015     
04016     virtual ::HxCorba::ImageRep_ptr HxXor(::HxCorba::ImageRep_ptr im1,
04017                                           ::HxCorba::ImageRep_ptr im2) = 0;
04018 
04019     
04020     
04021     
04022     virtual ::HxCorba::ImageRep_ptr HxAddVal(::HxCorba::ImageRep_ptr im,
04023                                              const ::HxCorba::PixValue& val) = 0;
04024 
04025     
04026     
04027     
04028     virtual ::HxCorba::ImageRep_ptr HxAndVal(::HxCorba::ImageRep_ptr im,
04029                                              const ::HxCorba::PixValue& val) = 0;
04030 
04031     
04032     
04033     
04034     virtual ::HxCorba::ImageRep_ptr HxCrossVal(::HxCorba::ImageRep_ptr im,
04035                                                const ::HxCorba::PixValue& val) = 0;
04036 
04037     
04038     
04039     
04040     virtual ::HxCorba::ImageRep_ptr HxDivVal(::HxCorba::ImageRep_ptr im,
04041                                              const ::HxCorba::PixValue& val) = 0;
04042 
04043     
04044     
04045     
04046     virtual ::HxCorba::ImageRep_ptr HxDotVal(::HxCorba::ImageRep_ptr im,
04047                                              const ::HxCorba::PixValue& val) = 0;
04048 
04049     
04050     
04051     
04052     virtual ::HxCorba::ImageRep_ptr HxEqualVal(::HxCorba::ImageRep_ptr im,
04053                                                const ::HxCorba::PixValue& val) = 0;
04054 
04055     
04056     
04057     
04058     virtual ::HxCorba::ImageRep_ptr HxGreaterEqualVal(::HxCorba::ImageRep_ptr im,
04059                                                       const ::HxCorba::PixValue& val) = 0;
04060 
04061     
04062     
04063     
04064     virtual ::HxCorba::ImageRep_ptr HxGreaterThanVal(::HxCorba::ImageRep_ptr im,
04065                                                      const ::HxCorba::PixValue& val) = 0;
04066 
04067     
04068     
04069     
04070     virtual ::HxCorba::ImageRep_ptr HxInfVal(::HxCorba::ImageRep_ptr im,
04071                                              const ::HxCorba::PixValue& val) = 0;
04072 
04073     
04074     
04075     
04076     virtual ::HxCorba::ImageRep_ptr HxLeftShiftVal(::HxCorba::ImageRep_ptr im,
04077                                                    const ::HxCorba::PixValue& val) = 0;
04078 
04079     
04080     
04081     
04082     virtual ::HxCorba::ImageRep_ptr HxLessEqualVal(::HxCorba::ImageRep_ptr im,
04083                                                    const ::HxCorba::PixValue& val) = 0;
04084 
04085     
04086     
04087     
04088     virtual ::HxCorba::ImageRep_ptr HxLessThanVal(::HxCorba::ImageRep_ptr im,
04089                                                   const ::HxCorba::PixValue& val) = 0;
04090 
04091     
04092     
04093     
04094     virtual ::HxCorba::ImageRep_ptr HxMaxVal(::HxCorba::ImageRep_ptr im,
04095                                              const ::HxCorba::PixValue& val) = 0;
04096 
04097     
04098     
04099     
04100     virtual ::HxCorba::ImageRep_ptr HxMinVal(::HxCorba::ImageRep_ptr im,
04101                                              const ::HxCorba::PixValue& val) = 0;
04102 
04103     
04104     
04105     
04106     virtual ::HxCorba::ImageRep_ptr HxModVal(::HxCorba::ImageRep_ptr im,
04107                                              const ::HxCorba::PixValue& val) = 0;
04108 
04109     
04110     
04111     
04112     virtual ::HxCorba::ImageRep_ptr HxMulVal(::HxCorba::ImageRep_ptr im,
04113                                              const ::HxCorba::PixValue& val) = 0;
04114 
04115     
04116     
04117     
04118     virtual ::HxCorba::ImageRep_ptr HxNotEqualVal(::HxCorba::ImageRep_ptr im,
04119                                                   const ::HxCorba::PixValue& val) = 0;
04120 
04121     
04122     
04123     
04124     virtual ::HxCorba::ImageRep_ptr HxOrVal(::HxCorba::ImageRep_ptr im,
04125                                             const ::HxCorba::PixValue& val) = 0;
04126 
04127     
04128     
04129     
04130     virtual ::HxCorba::ImageRep_ptr HxPowVal(::HxCorba::ImageRep_ptr im,
04131                                              const ::HxCorba::PixValue& val) = 0;
04132 
04133     
04134     
04135     
04136     virtual ::HxCorba::ImageRep_ptr HxRightShiftVal(::HxCorba::ImageRep_ptr im,
04137                                                     const ::HxCorba::PixValue& val) = 0;
04138 
04139     
04140     
04141     
04142     virtual ::HxCorba::ImageRep_ptr HxSubVal(::HxCorba::ImageRep_ptr im,
04143                                              const ::HxCorba::PixValue& val) = 0;
04144 
04145     
04146     
04147     
04148     virtual ::HxCorba::ImageRep_ptr HxSupVal(::HxCorba::ImageRep_ptr im,
04149                                              const ::HxCorba::PixValue& val) = 0;
04150 
04151     
04152     
04153     
04154     virtual ::HxCorba::ImageRep_ptr HxXorVal(::HxCorba::ImageRep_ptr im,
04155                                              const ::HxCorba::PixValue& val) = 0;
04156 
04157     
04158     
04159     
04160     virtual ::HxCorba::PixValue HxPixInf(::HxCorba::ImageRep_ptr im) = 0;
04161 
04162     
04163     
04164     
04165     virtual ::HxCorba::PixValue HxPixMax(::HxCorba::ImageRep_ptr im) = 0;
04166 
04167     
04168     
04169     
04170     virtual ::HxCorba::PixValue HxPixMin(::HxCorba::ImageRep_ptr im) = 0;
04171 
04172     
04173     
04174     
04175     virtual ::HxCorba::PixValue HxPixProduct(::HxCorba::ImageRep_ptr im) = 0;
04176 
04177     
04178     
04179     
04180     virtual ::HxCorba::PixValue HxPixSum(::HxCorba::ImageRep_ptr im) = 0;
04181 
04182     
04183     
04184     
04185     virtual ::HxCorba::PixValue HxPixSup(::HxCorba::ImageRep_ptr im) = 0;
04186 
04187     
04188     
04189     
04190     virtual ::HxCorba::ImageRep_ptr HxImageAsByte(::HxCorba::ImageRep_ptr img) = 0;
04191 
04192     
04193     
04194     
04195     virtual ::HxCorba::ImageRep_ptr HxImageAsDouble(::HxCorba::ImageRep_ptr img) = 0;
04196 
04197     
04198     
04199     
04200     virtual ::HxCorba::ImageRep_ptr HxImageAsFloat(::HxCorba::ImageRep_ptr img) = 0;
04201 
04202     
04203     
04204     
04205     virtual ::HxCorba::ImageRep_ptr HxImageAsShort(::HxCorba::ImageRep_ptr img) = 0;
04206 
04207     
04208     
04209     
04210     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Byte(::HxCorba::ImageRep_ptr img) = 0;
04211 
04212     
04213     
04214     
04215     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Double(::HxCorba::ImageRep_ptr img) = 0;
04216 
04217     
04218     
04219     
04220     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Float(::HxCorba::ImageRep_ptr img) = 0;
04221 
04222     
04223     
04224     
04225     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Int(::HxCorba::ImageRep_ptr img) = 0;
04226 
04227     
04228     
04229     
04230     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Short(::HxCorba::ImageRep_ptr img) = 0;
04231 
04232     
04233     
04234     
04235     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Byte(::HxCorba::ImageRep_ptr img) = 0;
04236 
04237     
04238     
04239     
04240     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Double(::HxCorba::ImageRep_ptr img) = 0;
04241 
04242     
04243     
04244     
04245     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Float(::HxCorba::ImageRep_ptr img) = 0;
04246 
04247     
04248     
04249     
04250     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Int(::HxCorba::ImageRep_ptr img) = 0;
04251 
04252     
04253     
04254     
04255     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Short(::HxCorba::ImageRep_ptr img) = 0;
04256 
04257     
04258     
04259     
04260     virtual ::HxCorba::ImageRep_ptr HxImageAsComplex(::HxCorba::ImageRep_ptr img) = 0;
04261 
04262     
04263     
04264     
04265     virtual ::HxCorba::ImageRep_ptr HxColorSpace(::HxCorba::ImageRep_ptr im,
04266                                                  ::HxCorba::ColorModel fromColorSpace,
04267                                                  ::HxCorba::ColorModel toColorSpace) = 0;
04268 
04269     
04270     
04271     
04272     virtual ::HxCorba::ImageRep_ptr HxAffinePix(::HxCorba::ImageRep_ptr im,
04273                                                 const ::HxCorba::PixValue& v1,
04274                                                 const ::HxCorba::PixValue& v2,
04275                                                 const ::HxCorba::PixValue& v3) = 0;
04276 
04277     
04278     
04279     
04280     virtual ::HxCorba::ImageRep_ptr HxRGB2Intensity(::HxCorba::ImageRep_ptr im) = 0;
04281 
04282     
04283     
04284     
04285     virtual ::HxCorba::Histogram_ptr HxGreyEdgeHistogram(::HxCorba::ImageRep_ptr objImage,
04286                                                          CORBA::Double sigma,
04287                                                          CORBA::Double threshold) = 0;
04288 
04289     
04290     
04291     
04292     virtual ::HxCorba::Histogram_ptr HxHistogramFromFile(const char* fileName) = 0;
04293 
04294     
04295     
04296     
04297     virtual ::HxCorba::Histogram_ptr HxImageToHistogram(::HxCorba::ImageRep_ptr im,
04298                                                         CORBA::Long getDim,
04299                                                         CORBA::Double lowBin,
04300                                                         CORBA::Double highBin,
04301                                                         CORBA::Long nBin) = 0;
04302 
04303     
04304     
04305     
04306     virtual ::HxCorba::Histogram_ptr HxImageToHistogramMask(::HxCorba::ImageRep_ptr im,
04307                                                             CORBA::Long getDim,
04308                                                             CORBA::Double lowBin,
04309                                                             CORBA::Double highBin,
04310                                                             CORBA::Long nBin,
04311                                                             ::HxCorba::ImageRep_ptr mask,
04312                                                             CORBA::Long maskVal) = 0;
04313 
04314     
04315     
04316     
04317     virtual ::HxCorba::Blob2dSet* HxLabelBlobs(::HxCorba::ImageRep_ptr image,
04318                                                ::HxCorba::ImageRep_ptr mask,
04319                                                CORBA::Long minimalBlobArea) = 0;
04320 
04321     
04322     
04323     
04324     virtual ::HxCorba::ImageRep_ptr HxHighlightRegion(::HxCorba::ImageRep_ptr im,
04325                                                       ::HxCorba::ImageRep_ptr mask,
04326                                                       CORBA::Long label,
04327                                                       CORBA::Double factor) = 0;
04328 
04329     
04330     
04331     
04332     virtual void HxExportMatlabPixels(::HxCorba::ImageRep_ptr im,
04333                                       ::HxCorba::DoubleSeq& pixels) = 0;
04334 
04335     
04336     
04337     
04338     virtual CORBA::Boolean HxWriteFile(::HxCorba::ImageRep_ptr im,
04339                                        const char* fileName) = 0;
04340 
04341     
04342     
04343     
04344     virtual CORBA::Boolean HxImagesToFile(const ::HxCorba::ImageList& ims,
04345                                           const char* fileName) = 0;
04346 
04347     
04348     
04349     
04350     virtual ::HxCorba::ImageRep_ptr HxCannyEdgeMap(::HxCorba::ImageRep_ptr img,
04351                                                    CORBA::Double sigma) = 0;
04352 
04353     
04354     
04355     
04356     virtual ::HxCorba::ImageRep_ptr HxCannyThreshold(::HxCorba::ImageRep_ptr img,
04357                                                      CORBA::Double sigma,
04358                                                      CORBA::Double level) = 0;
04359 
04360     
04361     
04362     
04363     virtual ::HxCorba::ImageRep_ptr HxCannyThresholdAlt(::HxCorba::ImageRep_ptr img,
04364                                                         CORBA::Double sigma,
04365                                                         CORBA::Double level) = 0;
04366 
04367     
04368     
04369     
04370     virtual ::HxCorba::ImageRep_ptr HxCannyThresholdRec(::HxCorba::ImageRep_ptr img,
04371                                                         CORBA::Double sigma,
04372                                                         CORBA::Double level) = 0;
04373 
04374     
04375     
04376     
04377     virtual ::HxCorba::ImageRep_ptr HxConvGauss2d(::HxCorba::ImageRep_ptr img,
04378                                                   CORBA::Double sigmax,
04379                                                   CORBA::Long orderDerivx,
04380                                                   CORBA::Double accuracyx,
04381                                                   CORBA::Double sigmay,
04382                                                   CORBA::Long orderDerivy,
04383                                                   CORBA::Double accuracyy) = 0;
04384 
04385     
04386     
04387     
04388     virtual ::HxCorba::ImageRep_ptr HxConvGauss3d(::HxCorba::ImageRep_ptr img,
04389                                                   CORBA::Double sigmax,
04390                                                   CORBA::Long orderDerivx,
04391                                                   CORBA::Double accuracyx,
04392                                                   CORBA::Double sigmay,
04393                                                   CORBA::Long orderDerivy,
04394                                                   CORBA::Double accuracyy,
04395                                                   CORBA::Double sigmaz,
04396                                                   CORBA::Long orderDerivz,
04397                                                   CORBA::Double accuracyz) = 0;
04398 
04399     
04400     
04401     
04402     virtual ::HxCorba::ImageRep_ptr HxConvKernelSeparated(::HxCorba::ImageRep_ptr im,
04403                                                           ::HxCorba::ImageRep_ptr kernel,
04404                                                           ::HxCorba::ResultPrecision resPrec) = 0;
04405 
04406     
04407     
04408     
04409     virtual ::HxCorba::ImageRep_ptr HxConvKernelSeparated2d(::HxCorba::ImageRep_ptr img,
04410                                                             ::HxCorba::ImageRep_ptr kernelX,
04411                                                             ::HxCorba::ImageRep_ptr kernelY,
04412                                                             ::HxCorba::ResultPrecision resPrec) = 0;
04413 
04414     
04415     
04416     
04417     virtual ::HxCorba::ImageRep_ptr HxConvolution(::HxCorba::ImageRep_ptr im,
04418                                                   ::HxCorba::ImageRep_ptr kernel,
04419                                                   ::HxCorba::ResultPrecision resPrec) = 0;
04420 
04421     
04422     
04423     
04424     virtual ::HxCorba::ImageRep_ptr HxDefuz(::HxCorba::ImageRep_ptr im,
04425                                             CORBA::Long windowSzX,
04426                                             CORBA::Long windowSzY,
04427                                             CORBA::Double thr) = 0;
04428 
04429     
04430     
04431     
04432     virtual ::HxCorba::ImageRep_ptr HxDistanceTransform(::HxCorba::ImageRep_ptr img) = 0;
04433 
04434     
04435     
04436     
04437     virtual ::HxCorba::ImageRep_ptr HxGauss(::HxCorba::ImageRep_ptr img,
04438                                             CORBA::Double sigma,
04439                                             CORBA::Double accuracy) = 0;
04440 
04441     
04442     
04443     
04444     virtual ::HxCorba::ImageRep_ptr HxGaussDerivative2d(::HxCorba::ImageRep_ptr img,
04445                                                         CORBA::Double sigma,
04446                                                         CORBA::Long orderDerivx,
04447                                                         CORBA::Long orderDerivy,
04448                                                         CORBA::Double accuracy) = 0;
04449 
04450     
04451     
04452     
04453     virtual ::HxCorba::ImageRep_ptr HxGaussDerivative3d(::HxCorba::ImageRep_ptr img,
04454                                                         CORBA::Double sigma,
04455                                                         CORBA::Long orderDerivx,
04456                                                         CORBA::Long orderDerivy,
04457                                                         CORBA::Long orderDerivz,
04458                                                         CORBA::Double accuracy) = 0;
04459 
04460     
04461     
04462     
04463     virtual ::HxCorba::ImageRep_ptr HxGaussianDeblur(::HxCorba::ImageRep_ptr im,
04464                                                      CORBA::Double dr,
04465                                                      CORBA::Double dc) = 0;
04466 
04467     
04468     
04469     
04470     virtual ::HxCorba::ImageRep_ptr HxKuwahara(::HxCorba::ImageRep_ptr im,
04471                                                CORBA::Long width,
04472                                                CORBA::Long height) = 0;
04473 
04474     
04475     
04476     
04477     virtual ::HxCorba::ImageRep_ptr HxLocalMode(::HxCorba::ImageRep_ptr f,
04478                                                 ::HxCorba::ImageRep_ptr g,
04479                                                 CORBA::Long nr,
04480                                                 CORBA::Double sigmax,
04481                                                 CORBA::Double sigmay,
04482                                                 CORBA::Double sigmaval,
04483                                                 const ::HxCorba::Sizes& ngbSize) = 0;
04484 
04485     
04486     
04487     
04488     virtual ::HxCorba::ImageRep_ptr HxNormalizedCorrelation(::HxCorba::ImageRep_ptr im,
04489                                                             ::HxCorba::ImageRep_ptr kernel) = 0;
04490 
04491     
04492     
04493     
04494     virtual ::HxCorba::ImageRep_ptr HxPercentile(::HxCorba::ImageRep_ptr im,
04495                                                  CORBA::Long neighSize,
04496                                                  CORBA::Double perc) = 0;
04497 
04498     
04499     
04500     
04501     virtual ::HxCorba::ImageRep_ptr HxRecGabor(::HxCorba::ImageRep_ptr im,
04502                                                CORBA::Double s,
04503                                                CORBA::Double omega0,
04504                                                CORBA::Double theta) = 0;
04505 
04506     
04507     
04508     
04509     virtual ::HxCorba::ImageRep_ptr HxRecGauss(::HxCorba::ImageRep_ptr im,
04510                                                CORBA::Double sx,
04511                                                CORBA::Double sy,
04512                                                CORBA::Long dx,
04513                                                CORBA::Long dy,
04514                                                CORBA::Long recurOrder) = 0;
04515 
04516     
04517     
04518     
04519     virtual ::HxCorba::ImageRep_ptr HxUniform(::HxCorba::ImageRep_ptr im,
04520                                               const ::HxCorba::Sizes& size) = 0;
04521 
04522     
04523     
04524     
04525     virtual ::HxCorba::ImageRep_ptr HxUniformNonSep(::HxCorba::ImageRep_ptr im,
04526                                                     const ::HxCorba::Sizes& size) = 0;
04527 
04528     
04529     
04530     
04531     virtual ::HxCorba::ImageRep_ptr HxMakeFrom2Images(::HxCorba::ImageRep_ptr i1,
04532                                                       ::HxCorba::ImageRep_ptr i2) = 0;
04533 
04534     
04535     
04536     
04537     virtual ::HxCorba::ImageRep_ptr HxMakeFrom3Images(::HxCorba::ImageRep_ptr i1,
04538                                                       ::HxCorba::ImageRep_ptr i2,
04539                                                       ::HxCorba::ImageRep_ptr i3) = 0;
04540 
04541     
04542     
04543     
04544     virtual ::HxCorba::ImageRep_ptr HxMakeFromByteData(CORBA::Long pixelDimensionality,
04545                                                        CORBA::Long dimensions,
04546                                                        const ::HxCorba::Sizes& size,
04547                                                        const ::HxCorba::OctetSeq& data) = 0;
04548 
04549     
04550     
04551     
04552     virtual ::HxCorba::ImageRep_ptr HxMakeFromDoubleData(CORBA::Long pixelDimensionality,
04553                                                          CORBA::Long dimensions,
04554                                                          const ::HxCorba::Sizes& size,
04555                                                          const ::HxCorba::DoubleSeq& data) = 0;
04556 
04557     
04558     
04559     
04560     virtual ::HxCorba::ImageRep_ptr HxMakeFromFile(const char* fileName) = 0;
04561 
04562     
04563     
04564     
04565     virtual ::HxCorba::ImageRep_ptr HxMakeFromFloatData(CORBA::Long pixelDimensionality,
04566                                                         CORBA::Long dimensions,
04567                                                         const ::HxCorba::Sizes& size,
04568                                                         const ::HxCorba::FloatSeq& data) = 0;
04569 
04570     
04571     
04572     
04573     virtual ::HxCorba::ImageRep_ptr HxMakeFromGrayValue(::HxCorba::ImageSignature signature,
04574                                                         const ::HxCorba::Sizes& size,
04575                                                         const ::HxCorba::OctetSeq& pixels) = 0;
04576 
04577     
04578     
04579     
04580     virtual ::HxCorba::ImageRep_ptr HxMakeFromImage(::HxCorba::ImageSignature signature,
04581                                                     ::HxCorba::ImageRep_ptr src) = 0;
04582 
04583     
04584     
04585     
04586     virtual ::HxCorba::ImageRep_ptr HxMakeFromImport(::HxCorba::ImageSignature signature,
04587                                                      const ::HxCorba::Sizes& size,
04588                                                      const char* importOp,
04589                                                      ::HxCorba::TagList_ptr tags) = 0;
04590 
04591     
04592     
04593     
04594     virtual ::HxCorba::ImageRep_ptr HxMakeFromIntData(CORBA::Long pixelDimensionality,
04595                                                       CORBA::Long dimensions,
04596                                                       const ::HxCorba::Sizes& size,
04597                                                       const ::HxCorba::LongSeq& data) = 0;
04598 
04599     
04600     
04601     
04602     virtual ::HxCorba::ImageRep_ptr HxMakeFromJavaRgb(::HxCorba::ImageSignature signature,
04603                                                       const ::HxCorba::Sizes& size,
04604                                                       const ::HxCorba::LongSeq& pixels) = 0;
04605 
04606     
04607     
04608     
04609     virtual ::HxCorba::ImageRep_ptr HxMakeFromMatlab(::HxCorba::ImageSignature signature,
04610                                                      const ::HxCorba::Sizes& size,
04611                                                      const ::HxCorba::DoubleSeq& pixels) = 0;
04612 
04613     
04614     
04615     
04616     virtual ::HxCorba::ImageRep_ptr HxMakeFromNamedGenerator(::HxCorba::ImageSignature signature,
04617                                                              const char* generatorName,
04618                                                              ::HxCorba::TagList_ptr tags) = 0;
04619 
04620     
04621     
04622     
04623     virtual ::HxCorba::ImageRep_ptr HxMakeFromPpmPixels(::HxCorba::ImageSignature signature,
04624                                                         const ::HxCorba::Sizes& size,
04625                                                         const ::HxCorba::OctetSeq& pixels) = 0;
04626 
04627     
04628     
04629     
04630     virtual ::HxCorba::ImageRep_ptr HxMakeFromShortData(CORBA::Long pixelDimensionality,
04631                                                         CORBA::Long dimensions,
04632                                                         const ::HxCorba::Sizes& size,
04633                                                         const ::HxCorba::ShortSeq& data) = 0;
04634 
04635     
04636     
04637     
04638     virtual ::HxCorba::ImageRep_ptr HxMakeFromSignature(::HxCorba::ImageSignature signature,
04639                                                         const ::HxCorba::Sizes& size) = 0;
04640 
04641     
04642     
04643     
04644     virtual ::HxCorba::ImageRep_ptr HxMakeFromValue(::HxCorba::ImageSignature signature,
04645                                                     const ::HxCorba::Sizes& size,
04646                                                     const ::HxCorba::PixValue& val) = 0;
04647 
04648     
04649     
04650     
04651     virtual ::HxCorba::ImageRep_ptr HxMakeGaussian1d(CORBA::Double sigma,
04652                                                      CORBA::Long deri,
04653                                                      CORBA::Double accuracy,
04654                                                      CORBA::Long maxfsize,
04655                                                      CORBA::Long fsize) = 0;
04656 
04657     
04658     
04659     
04660     virtual ::HxCorba::ImageRep_ptr HxMakeParabola1d(CORBA::Double rho,
04661                                                      CORBA::Double accuracy,
04662                                                      CORBA::Long maxfsize,
04663                                                      CORBA::Long fsize) = 0;
04664 
04665     
04666     
04667     
04668     virtual ::HxCorba::ImageList* HxImagesFromFile(const char* fileName) = 0;
04669 
04670     
04671     
04672     
04673     virtual ::HxCorba::ImageRep_ptr HxExtend(::HxCorba::ImageRep_ptr img,
04674                                              ::HxCorba::ImageRep_ptr background,
04675                                              const ::HxCorba::Point& begin) = 0;
04676 
04677     
04678     
04679     
04680     virtual ::HxCorba::ImageRep_ptr HxExtendVal(::HxCorba::ImageRep_ptr img,
04681                                                 const ::HxCorba::Sizes& newSize,
04682                                                 const ::HxCorba::PixValue& background,
04683                                                 const ::HxCorba::Point& begin) = 0;
04684 
04685     
04686     
04687     
04688     virtual ::HxCorba::ImageRep_ptr HxReflect(::HxCorba::ImageRep_ptr img,
04689                                               CORBA::Long doX,
04690                                               CORBA::Long doY,
04691                                               CORBA::Long doZ) = 0;
04692 
04693     
04694     
04695     
04696     virtual ::HxCorba::ImageRep_ptr HxRestrict(::HxCorba::ImageRep_ptr img,
04697                                                const ::HxCorba::Point& begin,
04698                                                const ::HxCorba::Point& end) = 0;
04699 
04700     
04701     
04702     
04703     virtual ::HxCorba::ImageRep_ptr HxRotate(::HxCorba::ImageRep_ptr img,
04704                                              CORBA::Double alpha,
04705                                              ::HxCorba::GeoIntType gi,
04706                                              CORBA::Long adjustSize,
04707                                              const ::HxCorba::PixValue& background) = 0;
04708 
04709     
04710     
04711     
04712     virtual ::HxCorba::ImageRep_ptr HxScale(::HxCorba::ImageRep_ptr img,
04713                                             CORBA::Double sx,
04714                                             CORBA::Double sy,
04715                                             CORBA::Double sz,
04716                                             ::HxCorba::GeoIntType gi,
04717                                             CORBA::Long adjustSize) = 0;
04718 
04719     
04720     
04721     
04722     virtual ::HxCorba::ImageRep_ptr HxTranslate(::HxCorba::ImageRep_ptr img,
04723                                                 CORBA::Long sx,
04724                                                 CORBA::Long sy,
04725                                                 CORBA::Long sz) = 0;
04726 
04727     
04728     
04729     
04730     virtual ::HxCorba::ImageRep_ptr HxTranspose(::HxCorba::ImageRep_ptr img) = 0;
04731 
04732     
04733     
04734     
04735     virtual CORBA::Long HxImageMaxSize(::HxCorba::ImageRep_ptr img) = 0;
04736 
04737     
04738     
04739     
04740     virtual CORBA::Long HxImageMinSize(::HxCorba::ImageRep_ptr img) = 0;
04741 
04742     
04743     
04744     
04745     virtual ::HxCorba::PixValue HxIdentMaskMean(::HxCorba::ImageRep_ptr im,
04746                                                 ::HxCorba::ImageRep_ptr mask,
04747                                                 const ::HxCorba::Point& p,
04748                                                 const ::HxCorba::Sizes& size,
04749                                                 CORBA::Long label) = 0;
04750 
04751     
04752     
04753     
04754     virtual ::HxCorba::PixValue HxIdentMaskMedian(::HxCorba::ImageRep_ptr im,
04755                                                   ::HxCorba::ImageRep_ptr mask,
04756                                                   const ::HxCorba::Point& p,
04757                                                   const ::HxCorba::Sizes& size,
04758                                                   CORBA::Long label) = 0;
04759 
04760     
04761     
04762     
04763     virtual ::HxCorba::PixValue HxIdentMaskStDev(::HxCorba::ImageRep_ptr im,
04764                                                  ::HxCorba::ImageRep_ptr mask,
04765                                                  const ::HxCorba::Point& p,
04766                                                  const ::HxCorba::Sizes& size,
04767                                                  CORBA::Long label) = 0;
04768 
04769     
04770     
04771     
04772     virtual ::HxCorba::PixValue HxIdentMaskSum(::HxCorba::ImageRep_ptr im,
04773                                                ::HxCorba::ImageRep_ptr mask,
04774                                                const ::HxCorba::Point& p,
04775                                                const ::HxCorba::Sizes& size,
04776                                                CORBA::Long label) = 0;
04777 
04778     
04779     
04780     
04781     virtual ::HxCorba::PixValue HxIdentMaskVariance(::HxCorba::ImageRep_ptr im,
04782                                                     ::HxCorba::ImageRep_ptr mask,
04783                                                     const ::HxCorba::Point& p,
04784                                                     const ::HxCorba::Sizes& size,
04785                                                     CORBA::Long label) = 0;
04786 
04787     
04788     
04789     
04790     virtual ::HxCorba::PixValue HxWeightMaskSum(::HxCorba::ImageRep_ptr im,
04791                                                 ::HxCorba::ImageRep_ptr mask,
04792                                                 const ::HxCorba::Point& p) = 0;
04793 
04794     
04795     
04796     
04797     virtual ::HxCorba::ImageRep_ptr HxAreaClosing(::HxCorba::ImageRep_ptr im,
04798                                                   CORBA::Long conn,
04799                                                   CORBA::Long minarea) = 0;
04800 
04801     
04802     
04803     
04804     virtual ::HxCorba::ImageRep_ptr HxAreaOpening(::HxCorba::ImageRep_ptr im,
04805                                                   CORBA::Long conn,
04806                                                   CORBA::Long area) = 0;
04807 
04808     
04809     
04810     
04811     virtual ::HxCorba::ImageRep_ptr HxClosing(::HxCorba::ImageRep_ptr im,
04812                                               ::HxCorba::SF_ptr s) = 0;
04813 
04814     
04815     
04816     
04817     virtual ::HxCorba::ImageRep_ptr HxClosingByReconstruction(::HxCorba::ImageRep_ptr im,
04818                                                               ::HxCorba::SF_ptr s1,
04819                                                               ::HxCorba::SF_ptr s2) = 0;
04820 
04821     
04822     
04823     
04824     virtual ::HxCorba::ImageRep_ptr HxClosingByReconstructionTopHat(::HxCorba::ImageRep_ptr im,
04825                                                                     ::HxCorba::SF_ptr s1,
04826                                                                     ::HxCorba::SF_ptr s2) = 0;
04827 
04828     
04829     
04830     
04831     virtual ::HxCorba::ImageRep_ptr HxClosingTopHat(::HxCorba::ImageRep_ptr im,
04832                                                     ::HxCorba::SF_ptr s) = 0;
04833 
04834     
04835     
04836     
04837     virtual ::HxCorba::ImageRep_ptr HxConditionalDilation(::HxCorba::ImageRep_ptr im,
04838                                                           ::HxCorba::ImageRep_ptr mask,
04839                                                           ::HxCorba::SF_ptr s,
04840                                                           CORBA::Long nrIter) = 0;
04841 
04842     
04843     
04844     
04845     virtual ::HxCorba::ImageRep_ptr HxConditionalErosion(::HxCorba::ImageRep_ptr im,
04846                                                          ::HxCorba::ImageRep_ptr mask,
04847                                                          ::HxCorba::SF_ptr s,
04848                                                          CORBA::Long nrIter) = 0;
04849 
04850     
04851     
04852     
04853     virtual ::HxCorba::ImageRep_ptr HxDilation(::HxCorba::ImageRep_ptr im,
04854                                                ::HxCorba::SF_ptr s) = 0;
04855 
04856     
04857     
04858     
04859     virtual ::HxCorba::ImageRep_ptr HxDistanceTransformMM(::HxCorba::ImageRep_ptr im,
04860                                                           ::HxCorba::SF_ptr s) = 0;
04861 
04862     
04863     
04864     
04865     virtual ::HxCorba::ImageRep_ptr HxErosion(::HxCorba::ImageRep_ptr im,
04866                                               ::HxCorba::SF_ptr s) = 0;
04867 
04868     
04869     
04870     
04871     virtual ::HxCorba::ImageRep_ptr HxGeodesicDistanceTransform(::HxCorba::ImageRep_ptr im,
04872                                                                 CORBA::Long conn) = 0;
04873 
04874     
04875     
04876     
04877     virtual ::HxCorba::ImageRep_ptr HxHilditchSkeleton(::HxCorba::ImageRep_ptr im) = 0;
04878 
04879     
04880     
04881     
04882     virtual ::HxCorba::ImageRep_ptr HxHitOrMiss(::HxCorba::ImageRep_ptr im,
04883                                                 ::HxCorba::SF_ptr s1,
04884                                                 ::HxCorba::SF_ptr s2) = 0;
04885 
04886     
04887     
04888     
04889     virtual ::HxCorba::ImageRep_ptr HxInfimumReconstruction(::HxCorba::ImageRep_ptr im,
04890                                                             ::HxCorba::ImageRep_ptr mask,
04891                                                             ::HxCorba::SF_ptr s) = 0;
04892 
04893     
04894     
04895     
04896     virtual ::HxCorba::ImageRep_ptr HxMorphologicalContour(::HxCorba::ImageRep_ptr im,
04897                                                            ::HxCorba::SF_ptr s) = 0;
04898 
04899     
04900     
04901     
04902     virtual ::HxCorba::ImageRep_ptr HxMorphologicalGradient(::HxCorba::ImageRep_ptr im,
04903                                                             ::HxCorba::SF_ptr s) = 0;
04904 
04905     
04906     
04907     
04908     virtual ::HxCorba::ImageRep_ptr HxMorphologicalGradient2(::HxCorba::ImageRep_ptr im,
04909                                                              ::HxCorba::SF_ptr s1,
04910                                                              ::HxCorba::SF_ptr s2) = 0;
04911 
04912     
04913     
04914     
04915     virtual ::HxCorba::ImageRep_ptr HxOpening(::HxCorba::ImageRep_ptr im,
04916                                               ::HxCorba::SF_ptr s) = 0;
04917 
04918     
04919     
04920     
04921     virtual ::HxCorba::ImageRep_ptr HxOpeningByReconstruction(::HxCorba::ImageRep_ptr im,
04922                                                               ::HxCorba::SF_ptr s1,
04923                                                               ::HxCorba::SF_ptr s2) = 0;
04924 
04925     
04926     
04927     
04928     virtual ::HxCorba::ImageRep_ptr HxOpeningByReconstructionTopHat(::HxCorba::ImageRep_ptr im,
04929                                                                     ::HxCorba::SF_ptr s1,
04930                                                                     ::HxCorba::SF_ptr s2) = 0;
04931 
04932     
04933     
04934     
04935     virtual ::HxCorba::ImageRep_ptr HxOpeningTopHat(::HxCorba::ImageRep_ptr im,
04936                                                     ::HxCorba::SF_ptr s) = 0;
04937 
04938     
04939     
04940     
04941     virtual ::HxCorba::ImageRep_ptr HxParabolicDilation(::HxCorba::ImageRep_ptr img,
04942                                                         CORBA::Double rho,
04943                                                         CORBA::Double accuracy) = 0;
04944 
04945     
04946     
04947     
04948     virtual ::HxCorba::ImageRep_ptr HxParabolicErosion(::HxCorba::ImageRep_ptr img,
04949                                                        CORBA::Double rho,
04950                                                        CORBA::Double accuracy) = 0;
04951 
04952     
04953     
04954     
04955     virtual ::HxCorba::ImageRep_ptr HxPeakRemoval(::HxCorba::ImageRep_ptr im,
04956                                                   CORBA::Long conn,
04957                                                   CORBA::Long minarea) = 0;
04958 
04959     
04960     
04961     
04962     virtual ::HxCorba::ImageRep_ptr HxRegionalMaxima(::HxCorba::ImageRep_ptr im,
04963                                                      CORBA::Long conn) = 0;
04964 
04965     
04966     
04967     
04968     virtual ::HxCorba::ImageRep_ptr HxRegionalMinima(::HxCorba::ImageRep_ptr im,
04969                                                      CORBA::Long conn) = 0;
04970 
04971     
04972     
04973     
04974     virtual ::HxCorba::ImageRep_ptr HxSKIZ(::HxCorba::ImageRep_ptr im,
04975                                            CORBA::Long conn) = 0;
04976 
04977     
04978     
04979     
04980     virtual ::HxCorba::ImageRep_ptr HxSkeleton(::HxCorba::ImageRep_ptr im,
04981                                                ::HxCorba::SF_ptr s) = 0;
04982 
04983     
04984     
04985     
04986     virtual ::HxCorba::ImageRep_ptr HxSupremumReconstruction(::HxCorba::ImageRep_ptr im,
04987                                                              ::HxCorba::ImageRep_ptr mask,
04988                                                              ::HxCorba::SF_ptr s) = 0;
04989 
04990     
04991     
04992     
04993     virtual ::HxCorba::ImageRep_ptr HxThickening(::HxCorba::ImageRep_ptr im,
04994                                                  ::HxCorba::SF_ptr s1,
04995                                                  ::HxCorba::SF_ptr s2) = 0;
04996 
04997     
04998     
04999     
05000     virtual ::HxCorba::ImageRep_ptr HxThinning(::HxCorba::ImageRep_ptr im,
05001                                                ::HxCorba::SF_ptr s1,
05002                                                ::HxCorba::SF_ptr s2) = 0;
05003 
05004     
05005     
05006     
05007     virtual ::HxCorba::ImageRep_ptr HxValleyRemoval(::HxCorba::ImageRep_ptr im,
05008                                                     CORBA::Long conn,
05009                                                     CORBA::Long minarea) = 0;
05010 
05011     
05012     
05013     
05014     virtual ::HxCorba::ImageRep_ptr HxWatershed(::HxCorba::ImageRep_ptr im,
05015                                                 CORBA::Long conn) = 0;
05016 
05017     
05018     
05019     
05020     virtual ::HxCorba::ImageRep_ptr HxWatershedMarkers(::HxCorba::ImageRep_ptr input,
05021                                                        ::HxCorba::ImageRep_ptr mask,
05022                                                        CORBA::Long conn,
05023                                                        CORBA::Boolean doLabelMask) = 0;
05024 
05025     
05026     
05027     
05028     virtual ::HxCorba::ImageRep_ptr HxWatershedMarkers2(::HxCorba::ImageRep_ptr input,
05029                                                         ::HxCorba::ImageRep_ptr mask,
05030                                                         CORBA::Long conn,
05031                                                         CORBA::Boolean doLabelMask,
05032                                                         CORBA::Long costMethod) = 0;
05033 
05034     
05035     
05036     
05037     virtual ::HxCorba::ImageRep_ptr HxWatershedSlow(::HxCorba::ImageRep_ptr im,
05038                                                     ::HxCorba::SF_ptr s,
05039                                                     const char* linereg) = 0;
05040 
05041     
05042     
05043     
05044     virtual ::HxCorba::ImageRep_ptr HxDisplayOF(::HxCorba::ImageRep_ptr im,
05045                                                 CORBA::Long scale_x,
05046                                                 CORBA::Long scale_y,
05047                                                 CORBA::Double mul_x,
05048                                                 CORBA::Double mul_y,
05049                                                 CORBA::Long pixelsize) = 0;
05050 
05051     
05052     
05053     
05054     virtual ::HxCorba::ImageRep_ptr HxOpticalFlow(::HxCorba::ImageRep_ptr im1,
05055                                                   ::HxCorba::ImageRep_ptr im2) = 0;
05056 
05057     
05058     
05059     
05060     virtual ::HxCorba::ImageRep_ptr HxOpticalFlowMultiScale(::HxCorba::ImageRep_ptr im1,
05061                                                             ::HxCorba::ImageRep_ptr im2) = 0;
05062 
05063     
05064     
05065     
05066     virtual ::HxCorba::ImageRep_ptr HxAddBinaryNoise(::HxCorba::ImageRep_ptr im,
05067                                                      CORBA::Double percent) = 0;
05068 
05069     
05070     
05071     
05072     virtual ::HxCorba::ImageRep_ptr HxAddGaussianNoise(::HxCorba::ImageRep_ptr im,
05073                                                        CORBA::Double mean,
05074                                                        CORBA::Double stdev) = 0;
05075 
05076     
05077     
05078     
05079     virtual ::HxCorba::ImageRep_ptr HxAddPoissonNoise(::HxCorba::ImageRep_ptr im,
05080                                                       CORBA::Double conversionFactor) = 0;
05081 
05082     
05083     
05084     
05085     virtual ::HxCorba::ImageRep_ptr HxAddUniformNoise(::HxCorba::ImageRep_ptr im) = 0;
05086 
05087     
05088     
05089     
05090     virtual ::HxCorba::ImageRep_ptr HxContrastStretch(::HxCorba::ImageRep_ptr im,
05091                                                       CORBA::Double val) = 0;
05092 
05093     
05094     
05095     
05096     virtual ::HxCorba::ImageRep_ptr HxSetBorderValue(::HxCorba::ImageRep_ptr im,
05097                                                      CORBA::Long w,
05098                                                      CORBA::Long h,
05099                                                      const ::HxCorba::PixValue& val) = 0;
05100 
05101     
05102     
05103     
05104     virtual ::HxCorba::ImageRep_ptr HxSetPartImage(::HxCorba::ImageRep_ptr im,
05105                                                    CORBA::Long x1,
05106                                                    CORBA::Long y1,
05107                                                    CORBA::Long x2,
05108                                                    CORBA::Long y2,
05109                                                    const ::HxCorba::PixValue& val) = 0;
05110 
05111     
05112     
05113     
05114     virtual ::HxCorba::ImageRep_ptr HxSquaredDistance(::HxCorba::ImageRep_ptr im1,
05115                                                       ::HxCorba::ImageRep_ptr im2) = 0;
05116 
05117     
05118     
05119     
05120     virtual ::HxCorba::ImageRep_ptr HxBernsenThreshold(::HxCorba::ImageRep_ptr im,
05121                                                        CORBA::Long windowSz,
05122                                                        CORBA::Long uniformTh,
05123                                                        CORBA::Boolean uniformLow) = 0;
05124 
05125     
05126     
05127     
05128     virtual ::HxCorba::ImageRep_ptr HxColorGaborSegmentation(::HxCorba::ImageRep_ptr im,
05129                                                              ::HxCorba::ColorGaborSegmentationAlgorithm segAlg,
05130                                                              ::HxCorba::ColorGaborSegmentationInvariant invariantType,
05131                                                              CORBA::Double minRegionFraction,
05132                                                              CORBA::Double threshold) = 0;
05133 
05134     
05135     
05136     
05137     virtual ::HxCorba::ImageRep_ptr HxEntropyThreshold(::HxCorba::ImageRep_ptr im) = 0;
05138 
05139     
05140     
05141     
05142     virtual ::HxCorba::ImageRep_ptr HxIsodataThreshold(::HxCorba::ImageRep_ptr im) = 0;
05143 
05144     
05145     
05146     
05147     virtual ::HxCorba::ImageRep_ptr HxLabel(::HxCorba::ImageRep_ptr im,
05148                                             CORBA::Long conn) = 0;
05149 
05150     
05151     
05152     
05153     virtual ::HxCorba::ImageRep_ptr HxLabel2(::HxCorba::ImageRep_ptr im,
05154                                              CORBA::Long conn) = 0;
05155 
05156     
05157     
05158     
05159     virtual ::HxCorba::ImageRep_ptr HxThreshold(::HxCorba::ImageRep_ptr im,
05160                                                 const ::HxCorba::PixValue& val) = 0;
05161 
05162     
05163     
05164     
05165     virtual ::HxCorba::ImageRep_ptr HxTriStateThreshold(::HxCorba::ImageRep_ptr im,
05166                                                         const ::HxCorba::PixValue& level,
05167                                                         const ::HxCorba::PixValue& v1,
05168                                                         const ::HxCorba::PixValue& v2,
05169                                                         const ::HxCorba::PixValue& v3) = 0;
05170 
05171     
05172     
05173     
05174     virtual CORBA::Boolean VxRelEquals(const ::HxCorba::VxTimeSpan& elt1,
05175                                        const ::HxCorba::VxTimeSpan& elt2) = 0;
05176 
05177     
05178     
05179     
05180     virtual CORBA::Boolean VxRelMeets(const ::HxCorba::VxTimeSpan& elt1,
05181                                       const ::HxCorba::VxTimeSpan& elt2) = 0;
05182 
05183     
05184     
05185     
05186     virtual CORBA::Boolean VxRelBefore(const ::HxCorba::VxTimeSpan& elt1,
05187                                        const ::HxCorba::VxTimeSpan& elt2) = 0;
05188 
05189     
05190     
05191     
05192     virtual CORBA::Boolean VxRelOverlaps(const ::HxCorba::VxTimeSpan& elt1,
05193                                          const ::HxCorba::VxTimeSpan& elt2) = 0;
05194 
05195     
05196     
05197     
05198     virtual CORBA::Boolean VxRelDur(const ::HxCorba::VxTimeSpan& elt1,
05199                                     const ::HxCorba::VxTimeSpan& elt2) = 0;
05200 
05201     
05202     
05203     
05204     virtual CORBA::Boolean VxRelCon(const ::HxCorba::VxTimeSpan& elt1,
05205                                     const ::HxCorba::VxTimeSpan& elt2) = 0;
05206 
05207     
05208     
05209     
05210     virtual CORBA::Boolean VxRelMeetsAnywhere(const ::HxCorba::VxTimeSpan& elt1,
05211                                               const ::HxCorba::VxTimeSpan& elt2) = 0;
05212 
05213     
05214     
05215     
05216     virtual CORBA::Boolean VxRelBeforeAfter(const ::HxCorba::VxTimeSpan& elt1,
05217                                             const ::HxCorba::VxTimeSpan& elt2) = 0;
05218 
05219     
05220     
05221     
05222     virtual CORBA::Boolean VxRelOverlapsAnywhere(const ::HxCorba::VxTimeSpan& elt1,
05223                                                  const ::HxCorba::VxTimeSpan& elt2) = 0;
05224 
05225     
05226     
05227     
05228     virtual char* VxRelAsString(const ::HxCorba::VxTimeSpan& elt1,
05229                                 const ::HxCorba::VxTimeSpan& elt2) = 0;
05230 
05231     
05232     
05233     
05234     virtual void HxIDBOpen(const char* name,
05235                            const char* indexFile) = 0;
05236 
05237     
05238     
05239     
05240     virtual ::HxCorba::StringSeq* HxIDBRandom(const char* name,
05241                                               CORBA::Long n) = 0;
05242 
05243     
05244     
05245     
05246     virtual ::HxCorba::StringSeq* HxIDBSearch(const char* key,
05247                                               const char* name,
05248                                               CORBA::Long n) = 0;
05249 
05250     
05251     
05252     
05253     virtual void HxInvarOpenDB(const char* indexFile,
05254                                const char* dbDir) = 0;
05255 
05256     
05257     
05258     
05259     virtual ::HxCorba::StringSeq* HxInvarRandom(const char* invar,
05260                                                 CORBA::Long n) = 0;
05261 
05262     
05263     
05264     
05265     virtual ::HxCorba::StringSeq* HxInvarSearch(::HxCorba::ImageRep_ptr im,
05266                                                 const char* invar,
05267                                                 CORBA::Long n) = 0;
05268 
05269     
05270     
05271     
05272     virtual ::HxCorba::StringSeq* HxInvarSearchHisto(const ::HxCorba::HistogramList& target,
05273                                                      const char* invar,
05274                                                      CORBA::Long n) = 0;
05275 
05276     
05277     
05278     
05279     virtual CORBA::Double HxInvarMatchHistos(const ::HxCorba::HistogramList& l1,
05280                                              const ::HxCorba::HistogramList& l2) = 0;
05281 
05282     
05283     
05284     
05285     virtual void HxInvarIndexDB(const char* indexFile,
05286                                 const char* dbDir,
05287                                 const char* invar,
05288                                 CORBA::Double s,
05289                                 CORBA::Long bins) = 0;
05290 
05291     
05292     
05293     
05294     virtual CORBA::Long HxInvarDBSize(const char* invar) = 0;
05295 
05296     
05297     
05298     
05299     virtual CORBA::Long HxInvarBinsPerHistogram(const char* invar) = 0;
05300 
05301     
05302     
05303     
05304     virtual CORBA::Long HxInvarChannels(const char* invar) = 0;
05305 
05306     
05307     
05308     
05309     virtual ::HxCorba::StringSeq* HxInvarDBList(const char* invar) = 0;
05310 
05311     
05312     
05313     
05314     virtual ::HxCorba::FloatSeq* HxInvarGetHistos(const char* invar,
05315                                                   const char* key) = 0;
05316 
05317     
05318     
05319     
05320     virtual ::HxCorba::StringSeq* HxInvarSearchKey(const char* key,
05321                                                    const char* invar,
05322                                                    CORBA::Long n) = 0;
05323 
05324     
05325     
05326     
05327     virtual ::HxCorba::DoubleSeq* HxInvarScores(const char* invar,
05328                                                 CORBA::Long n) = 0;
05329 
05330     
05331     
05332     
05333     virtual ::HxCorba::ImageRep_ptr HxNJetInvarE(::HxCorba::NJet_ptr nj) = 0;
05334 
05335     
05336     
05337     
05338     virtual ::HxCorba::ImageRep_ptr HxNJetInvarC(::HxCorba::NJet_ptr nj) = 0;
05339 
05340     
05341     
05342     
05343     virtual ::HxCorba::ImageRep_ptr HxNJetInvarWw(::HxCorba::NJet_ptr nj) = 0;
05344 
05345     
05346     
05347     
05348     virtual ::HxCorba::ImageRep_ptr HxNJetInvarCw(::HxCorba::NJet_ptr nj) = 0;
05349 
05350     
05351     
05352     
05353     virtual ::HxCorba::HistogramList* HxNJetInvarEHisto(::HxCorba::NJet_ptr nj,
05354                                                         CORBA::Long nBin) = 0;
05355 
05356     
05357     
05358     
05359     virtual ::HxCorba::HistogramList* HxNJetInvarCHisto(::HxCorba::NJet_ptr nj,
05360                                                         CORBA::Long nBin) = 0;
05361 
05362     
05363     
05364     
05365     virtual ::HxCorba::HistogramList* HxNJetInvarWwHisto(::HxCorba::NJet_ptr nj,
05366                                                          CORBA::Long nBin) = 0;
05367 
05368     
05369     
05370     
05371     virtual ::HxCorba::HistogramList* HxNJetInvarCwHisto(::HxCorba::NJet_ptr nj,
05372                                                          CORBA::Long nBin) = 0;
05373 
05374     
05375     
05376     
05377     virtual ::HxCorba::HistogramList* HxInvarEHisto(::HxCorba::ImageRep_ptr im,
05378                                                     CORBA::Double scale,
05379                                                     CORBA::Long nBin) = 0;
05380 
05381     
05382     
05383     
05384     virtual ::HxCorba::HistogramList* HxInvarCHisto(::HxCorba::ImageRep_ptr im,
05385                                                     CORBA::Double scale,
05386                                                     CORBA::Long nBin) = 0;
05387 
05388     
05389     
05390     
05391     virtual ::HxCorba::HistogramList* HxInvarWwHisto(::HxCorba::ImageRep_ptr im,
05392                                                      CORBA::Double scale,
05393                                                      CORBA::Long nBin) = 0;
05394 
05395     
05396     
05397     
05398     virtual ::HxCorba::HistogramList* HxInvarCwHisto(::HxCorba::ImageRep_ptr im,
05399                                                      CORBA::Double scale,
05400                                                      CORBA::Long nBin) = 0;
05401 
05402     
05403     
05404     
05405     virtual ::HxCorba::DoubleSeqSeq* HxNJetInvar(::HxCorba::ImageRep_ptr im,
05406                                                  const char* invar,
05407                                                  CORBA::Double scale,
05408                                                  CORBA::Long nBin) = 0;
05409 
05410     
05411     
05412     
05413     virtual ::HxCorba::ImageRep_ptr HxColorInvarEw(::HxCorba::ImageRep_ptr im,
05414                                                    CORBA::Double scale) = 0;
05415 
05416     
05417     
05418     
05419     virtual ::HxCorba::ImageRep_ptr HxColorInvarWw(::HxCorba::ImageRep_ptr im,
05420                                                    CORBA::Double scale) = 0;
05421 
05422     
05423     
05424     
05425     virtual ::HxCorba::ImageRep_ptr HxColorInvarCw(::HxCorba::ImageRep_ptr im,
05426                                                    CORBA::Double scale) = 0;
05427 
05428     
05429     
05430     
05431     virtual ::HxCorba::ImageRep_ptr HxColorInvarNw(::HxCorba::ImageRep_ptr im,
05432                                                    CORBA::Double scale) = 0;
05433 
05434     
05435     
05436     
05437     virtual ::HxCorba::ImageRep_ptr HxColorInvarHw(::HxCorba::ImageRep_ptr im,
05438                                                    CORBA::Double scale) = 0;
05439 };
05440 
05441 } 
05442 
05443 
05444 
05445 
05446 namespace OBMarshalStubImpl_HxCorba
05447 {
05448 
05449 
05450 
05451 
05452 class GlobalOps : virtual public OBStubImpl_HxCorba::GlobalOps,
05453                   virtual public OBMarshalStubImpl_HxCorba::UserOps
05454 {
05455     GlobalOps(const GlobalOps&);
05456     void operator=(const GlobalOps&);
05457 
05458 protected:
05459 
05460     GlobalOps() { }
05461     friend class OBProxy_HxCorba::GlobalOps;
05462 
05463 public:
05464 
05465     
05466     
05467     
05468     virtual ::HxCorba::ImageRep_ptr HxAbs(::HxCorba::ImageRep_ptr im);
05469 
05470     
05471     
05472     
05473     virtual ::HxCorba::ImageRep_ptr HxCeil(::HxCorba::ImageRep_ptr im);
05474 
05475     
05476     
05477     
05478     virtual ::HxCorba::ImageRep_ptr HxComplement(::HxCorba::ImageRep_ptr im);
05479 
05480     
05481     
05482     
05483     virtual ::HxCorba::ImageRep_ptr HxExp(::HxCorba::ImageRep_ptr im);
05484 
05485     
05486     
05487     
05488     virtual ::HxCorba::ImageRep_ptr HxFloor(::HxCorba::ImageRep_ptr im);
05489 
05490     
05491     
05492     
05493     virtual ::HxCorba::ImageRep_ptr HxLog(::HxCorba::ImageRep_ptr im);
05494 
05495     
05496     
05497     
05498     virtual ::HxCorba::ImageRep_ptr HxLog10(::HxCorba::ImageRep_ptr im);
05499 
05500     
05501     
05502     
05503     virtual ::HxCorba::ImageRep_ptr HxNegate(::HxCorba::ImageRep_ptr im);
05504 
05505     
05506     
05507     
05508     virtual ::HxCorba::ImageRep_ptr HxNorm1(::HxCorba::ImageRep_ptr im);
05509 
05510     
05511     
05512     
05513     virtual ::HxCorba::ImageRep_ptr HxNorm2(::HxCorba::ImageRep_ptr im);
05514 
05515     
05516     
05517     
05518     virtual ::HxCorba::ImageRep_ptr HxNormInf(::HxCorba::ImageRep_ptr im);
05519 
05520     
05521     
05522     
05523     virtual ::HxCorba::ImageRep_ptr HxProjectRange(::HxCorba::ImageRep_ptr im,
05524                                                    CORBA::Long dimension);
05525 
05526     
05527     
05528     
05529     virtual ::HxCorba::ImageRep_ptr HxReciprocal(::HxCorba::ImageRep_ptr im);
05530 
05531     
05532     
05533     
05534     virtual ::HxCorba::ImageRep_ptr HxSqrt(::HxCorba::ImageRep_ptr im);
05535 
05536     
05537     
05538     
05539     virtual ::HxCorba::ImageRep_ptr HxRound(::HxCorba::ImageRep_ptr im);
05540 
05541     
05542     
05543     
05544     virtual ::HxCorba::ImageRep_ptr HxUnaryMax(::HxCorba::ImageRep_ptr im);
05545 
05546     
05547     
05548     
05549     virtual ::HxCorba::ImageRep_ptr HxUnaryMin(::HxCorba::ImageRep_ptr im);
05550 
05551     
05552     
05553     
05554     virtual ::HxCorba::ImageRep_ptr HxUnaryProduct(::HxCorba::ImageRep_ptr im);
05555 
05556     
05557     
05558     
05559     virtual ::HxCorba::ImageRep_ptr HxUnarySum(::HxCorba::ImageRep_ptr im);
05560 
05561     
05562     
05563     
05564     virtual ::HxCorba::ImageRep_ptr HxAcos(::HxCorba::ImageRep_ptr im);
05565 
05566     
05567     
05568     
05569     virtual ::HxCorba::ImageRep_ptr HxAsin(::HxCorba::ImageRep_ptr im);
05570 
05571     
05572     
05573     
05574     virtual ::HxCorba::ImageRep_ptr HxAtan(::HxCorba::ImageRep_ptr im);
05575 
05576     
05577     
05578     
05579     virtual ::HxCorba::ImageRep_ptr HxAtan2(::HxCorba::ImageRep_ptr im);
05580 
05581     
05582     
05583     
05584     virtual ::HxCorba::ImageRep_ptr HxCos(::HxCorba::ImageRep_ptr im);
05585 
05586     
05587     
05588     
05589     virtual ::HxCorba::ImageRep_ptr HxCosh(::HxCorba::ImageRep_ptr im);
05590 
05591     
05592     
05593     
05594     virtual ::HxCorba::ImageRep_ptr HxSin(::HxCorba::ImageRep_ptr im);
05595 
05596     
05597     
05598     
05599     virtual ::HxCorba::ImageRep_ptr HxSinh(::HxCorba::ImageRep_ptr im);
05600 
05601     
05602     
05603     
05604     virtual ::HxCorba::ImageRep_ptr HxTan(::HxCorba::ImageRep_ptr im);
05605 
05606     
05607     
05608     
05609     virtual ::HxCorba::ImageRep_ptr HxTanh(::HxCorba::ImageRep_ptr im);
05610 
05611     
05612     
05613     
05614     virtual ::HxCorba::ImageRep_ptr HxArg(::HxCorba::ImageRep_ptr im);
05615 
05616     
05617     
05618     
05619     virtual ::HxCorba::ImageRep_ptr HxConjugate(::HxCorba::ImageRep_ptr im);
05620 
05621     
05622     
05623     
05624     virtual ::HxCorba::ImageRep_ptr HxAdd(::HxCorba::ImageRep_ptr im1,
05625                                           ::HxCorba::ImageRep_ptr im2);
05626 
05627     
05628     
05629     
05630     virtual ::HxCorba::ImageRep_ptr HxAddSat(::HxCorba::ImageRep_ptr im1,
05631                                              ::HxCorba::ImageRep_ptr im2);
05632 
05633     
05634     
05635     
05636     virtual ::HxCorba::ImageRep_ptr HxAnd(::HxCorba::ImageRep_ptr im1,
05637                                           ::HxCorba::ImageRep_ptr im2);
05638 
05639     
05640     
05641     
05642     virtual ::HxCorba::ImageRep_ptr HxCross(::HxCorba::ImageRep_ptr im1,
05643                                             ::HxCorba::ImageRep_ptr im2);
05644 
05645     
05646     
05647     
05648     virtual ::HxCorba::ImageRep_ptr HxDiv(::HxCorba::ImageRep_ptr im1,
05649                                           ::HxCorba::ImageRep_ptr im2);
05650 
05651     
05652     
05653     
05654     virtual ::HxCorba::ImageRep_ptr HxDot(::HxCorba::ImageRep_ptr im1,
05655                                           ::HxCorba::ImageRep_ptr im2);
05656 
05657     
05658     
05659     
05660     virtual ::HxCorba::ImageRep_ptr HxEqual(::HxCorba::ImageRep_ptr im1,
05661                                             ::HxCorba::ImageRep_ptr im2);
05662 
05663     
05664     
05665     
05666     virtual ::HxCorba::ImageRep_ptr HxGreaterEqual(::HxCorba::ImageRep_ptr im1,
05667                                                    ::HxCorba::ImageRep_ptr im2);
05668 
05669     
05670     
05671     
05672     virtual ::HxCorba::ImageRep_ptr HxGreaterThan(::HxCorba::ImageRep_ptr im1,
05673                                                   ::HxCorba::ImageRep_ptr im2);
05674 
05675     
05676     
05677     
05678     virtual ::HxCorba::ImageRep_ptr HxInf(::HxCorba::ImageRep_ptr im1,
05679                                           ::HxCorba::ImageRep_ptr im2);
05680 
05681     
05682     
05683     
05684     virtual ::HxCorba::ImageRep_ptr HxInverseProjectRange(::HxCorba::ImageRep_ptr im1,
05685                                                           CORBA::Long dimension,
05686                                                           ::HxCorba::ImageRep_ptr im2);
05687 
05688     
05689     
05690     
05691     virtual ::HxCorba::ImageRep_ptr HxLeftShift(::HxCorba::ImageRep_ptr im1,
05692                                                 ::HxCorba::ImageRep_ptr im2);
05693 
05694     
05695     
05696     
05697     virtual ::HxCorba::ImageRep_ptr HxLessEqual(::HxCorba::ImageRep_ptr im1,
05698                                                 ::HxCorba::ImageRep_ptr im2);
05699 
05700     
05701     
05702     
05703     virtual ::HxCorba::ImageRep_ptr HxLessThan(::HxCorba::ImageRep_ptr im1,
05704                                                ::HxCorba::ImageRep_ptr im2);
05705 
05706     
05707     
05708     
05709     virtual ::HxCorba::ImageRep_ptr HxMax(::HxCorba::ImageRep_ptr im1,
05710                                           ::HxCorba::ImageRep_ptr im2);
05711 
05712     
05713     
05714     
05715     virtual ::HxCorba::ImageRep_ptr HxMin(::HxCorba::ImageRep_ptr im1,
05716                                           ::HxCorba::ImageRep_ptr im2);
05717 
05718     
05719     
05720     
05721     virtual ::HxCorba::ImageRep_ptr HxMod(::HxCorba::ImageRep_ptr im1,
05722                                           ::HxCorba::ImageRep_ptr im2);
05723 
05724     
05725     
05726     
05727     virtual ::HxCorba::ImageRep_ptr HxMul(::HxCorba::ImageRep_ptr im1,
05728                                           ::HxCorba::ImageRep_ptr im2);
05729 
05730     
05731     
05732     
05733     virtual ::HxCorba::ImageRep_ptr HxNotEqual(::HxCorba::ImageRep_ptr im1,
05734                                                ::HxCorba::ImageRep_ptr im2);
05735 
05736     
05737     
05738     
05739     virtual ::HxCorba::ImageRep_ptr HxOr(::HxCorba::ImageRep_ptr im1,
05740                                          ::HxCorba::ImageRep_ptr im2);
05741 
05742     
05743     
05744     
05745     virtual ::HxCorba::ImageRep_ptr HxPow(::HxCorba::ImageRep_ptr im1,
05746                                           ::HxCorba::ImageRep_ptr im2);
05747 
05748     
05749     
05750     
05751     virtual ::HxCorba::ImageRep_ptr HxRightShift(::HxCorba::ImageRep_ptr im1,
05752                                                  ::HxCorba::ImageRep_ptr im2);
05753 
05754     
05755     
05756     
05757     virtual ::HxCorba::ImageRep_ptr HxSub(::HxCorba::ImageRep_ptr im1,
05758                                           ::HxCorba::ImageRep_ptr im2);
05759 
05760     
05761     
05762     
05763     virtual ::HxCorba::ImageRep_ptr HxSubSat(::HxCorba::ImageRep_ptr im1,
05764                                              ::HxCorba::ImageRep_ptr im2);
05765 
05766     
05767     
05768     
05769     virtual ::HxCorba::ImageRep_ptr HxSup(::HxCorba::ImageRep_ptr im1,
05770                                           ::HxCorba::ImageRep_ptr im2);
05771 
05772     
05773     
05774     
05775     virtual ::HxCorba::ImageRep_ptr HxXor(::HxCorba::ImageRep_ptr im1,
05776                                           ::HxCorba::ImageRep_ptr im2);
05777 
05778     
05779     
05780     
05781     virtual ::HxCorba::ImageRep_ptr HxAddVal(::HxCorba::ImageRep_ptr im,
05782                                              const ::HxCorba::PixValue& val);
05783 
05784     
05785     
05786     
05787     virtual ::HxCorba::ImageRep_ptr HxAndVal(::HxCorba::ImageRep_ptr im,
05788                                              const ::HxCorba::PixValue& val);
05789 
05790     
05791     
05792     
05793     virtual ::HxCorba::ImageRep_ptr HxCrossVal(::HxCorba::ImageRep_ptr im,
05794                                                const ::HxCorba::PixValue& val);
05795 
05796     
05797     
05798     
05799     virtual ::HxCorba::ImageRep_ptr HxDivVal(::HxCorba::ImageRep_ptr im,
05800                                              const ::HxCorba::PixValue& val);
05801 
05802     
05803     
05804     
05805     virtual ::HxCorba::ImageRep_ptr HxDotVal(::HxCorba::ImageRep_ptr im,
05806                                              const ::HxCorba::PixValue& val);
05807 
05808     
05809     
05810     
05811     virtual ::HxCorba::ImageRep_ptr HxEqualVal(::HxCorba::ImageRep_ptr im,
05812                                                const ::HxCorba::PixValue& val);
05813 
05814     
05815     
05816     
05817     virtual ::HxCorba::ImageRep_ptr HxGreaterEqualVal(::HxCorba::ImageRep_ptr im,
05818                                                       const ::HxCorba::PixValue& val);
05819 
05820     
05821     
05822     
05823     virtual ::HxCorba::ImageRep_ptr HxGreaterThanVal(::HxCorba::ImageRep_ptr im,
05824                                                      const ::HxCorba::PixValue& val);
05825 
05826     
05827     
05828     
05829     virtual ::HxCorba::ImageRep_ptr HxInfVal(::HxCorba::ImageRep_ptr im,
05830                                              const ::HxCorba::PixValue& val);
05831 
05832     
05833     
05834     
05835     virtual ::HxCorba::ImageRep_ptr HxLeftShiftVal(::HxCorba::ImageRep_ptr im,
05836                                                    const ::HxCorba::PixValue& val);
05837 
05838     
05839     
05840     
05841     virtual ::HxCorba::ImageRep_ptr HxLessEqualVal(::HxCorba::ImageRep_ptr im,
05842                                                    const ::HxCorba::PixValue& val);
05843 
05844     
05845     
05846     
05847     virtual ::HxCorba::ImageRep_ptr HxLessThanVal(::HxCorba::ImageRep_ptr im,
05848                                                   const ::HxCorba::PixValue& val);
05849 
05850     
05851     
05852     
05853     virtual ::HxCorba::ImageRep_ptr HxMaxVal(::HxCorba::ImageRep_ptr im,
05854                                              const ::HxCorba::PixValue& val);
05855 
05856     
05857     
05858     
05859     virtual ::HxCorba::ImageRep_ptr HxMinVal(::HxCorba::ImageRep_ptr im,
05860                                              const ::HxCorba::PixValue& val);
05861 
05862     
05863     
05864     
05865     virtual ::HxCorba::ImageRep_ptr HxModVal(::HxCorba::ImageRep_ptr im,
05866                                              const ::HxCorba::PixValue& val);
05867 
05868     
05869     
05870     
05871     virtual ::HxCorba::ImageRep_ptr HxMulVal(::HxCorba::ImageRep_ptr im,
05872                                              const ::HxCorba::PixValue& val);
05873 
05874     
05875     
05876     
05877     virtual ::HxCorba::ImageRep_ptr HxNotEqualVal(::HxCorba::ImageRep_ptr im,
05878                                                   const ::HxCorba::PixValue& val);
05879 
05880     
05881     
05882     
05883     virtual ::HxCorba::ImageRep_ptr HxOrVal(::HxCorba::ImageRep_ptr im,
05884                                             const ::HxCorba::PixValue& val);
05885 
05886     
05887     
05888     
05889     virtual ::HxCorba::ImageRep_ptr HxPowVal(::HxCorba::ImageRep_ptr im,
05890                                              const ::HxCorba::PixValue& val);
05891 
05892     
05893     
05894     
05895     virtual ::HxCorba::ImageRep_ptr HxRightShiftVal(::HxCorba::ImageRep_ptr im,
05896                                                     const ::HxCorba::PixValue& val);
05897 
05898     
05899     
05900     
05901     virtual ::HxCorba::ImageRep_ptr HxSubVal(::HxCorba::ImageRep_ptr im,
05902                                              const ::HxCorba::PixValue& val);
05903 
05904     
05905     
05906     
05907     virtual ::HxCorba::ImageRep_ptr HxSupVal(::HxCorba::ImageRep_ptr im,
05908                                              const ::HxCorba::PixValue& val);
05909 
05910     
05911     
05912     
05913     virtual ::HxCorba::ImageRep_ptr HxXorVal(::HxCorba::ImageRep_ptr im,
05914                                              const ::HxCorba::PixValue& val);
05915 
05916     
05917     
05918     
05919     virtual ::HxCorba::PixValue HxPixInf(::HxCorba::ImageRep_ptr im);
05920 
05921     
05922     
05923     
05924     virtual ::HxCorba::PixValue HxPixMax(::HxCorba::ImageRep_ptr im);
05925 
05926     
05927     
05928     
05929     virtual ::HxCorba::PixValue HxPixMin(::HxCorba::ImageRep_ptr im);
05930 
05931     
05932     
05933     
05934     virtual ::HxCorba::PixValue HxPixProduct(::HxCorba::ImageRep_ptr im);
05935 
05936     
05937     
05938     
05939     virtual ::HxCorba::PixValue HxPixSum(::HxCorba::ImageRep_ptr im);
05940 
05941     
05942     
05943     
05944     virtual ::HxCorba::PixValue HxPixSup(::HxCorba::ImageRep_ptr im);
05945 
05946     
05947     
05948     
05949     virtual ::HxCorba::ImageRep_ptr HxImageAsByte(::HxCorba::ImageRep_ptr img);
05950 
05951     
05952     
05953     
05954     virtual ::HxCorba::ImageRep_ptr HxImageAsDouble(::HxCorba::ImageRep_ptr img);
05955 
05956     
05957     
05958     
05959     virtual ::HxCorba::ImageRep_ptr HxImageAsFloat(::HxCorba::ImageRep_ptr img);
05960 
05961     
05962     
05963     
05964     virtual ::HxCorba::ImageRep_ptr HxImageAsShort(::HxCorba::ImageRep_ptr img);
05965 
05966     
05967     
05968     
05969     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Byte(::HxCorba::ImageRep_ptr img);
05970 
05971     
05972     
05973     
05974     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Double(::HxCorba::ImageRep_ptr img);
05975 
05976     
05977     
05978     
05979     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Float(::HxCorba::ImageRep_ptr img);
05980 
05981     
05982     
05983     
05984     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Int(::HxCorba::ImageRep_ptr img);
05985 
05986     
05987     
05988     
05989     virtual ::HxCorba::ImageRep_ptr HxImageAsVec2Short(::HxCorba::ImageRep_ptr img);
05990 
05991     
05992     
05993     
05994     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Byte(::HxCorba::ImageRep_ptr img);
05995 
05996     
05997     
05998     
05999     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Double(::HxCorba::ImageRep_ptr img);
06000 
06001     
06002     
06003     
06004     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Float(::HxCorba::ImageRep_ptr img);
06005 
06006     
06007     
06008     
06009     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Int(::HxCorba::ImageRep_ptr img);
06010 
06011     
06012     
06013     
06014     virtual ::HxCorba::ImageRep_ptr HxImageAsVec3Short(::HxCorba::ImageRep_ptr img);
06015 
06016     
06017     
06018     
06019     virtual ::HxCorba::ImageRep_ptr HxImageAsComplex(::HxCorba::ImageRep_ptr img);
06020 
06021     
06022     
06023     
06024     virtual ::HxCorba::ImageRep_ptr HxColorSpace(::HxCorba::ImageRep_ptr im,
06025                                                  ::HxCorba::ColorModel fromColorSpace,
06026                                                  ::HxCorba::ColorModel toColorSpace);
06027 
06028     
06029     
06030     
06031     virtual ::HxCorba::ImageRep_ptr HxAffinePix(::HxCorba::ImageRep_ptr im,
06032                                                 const ::HxCorba::PixValue& v1,
06033                                                 const ::HxCorba::PixValue& v2,
06034                                                 const ::HxCorba::PixValue& v3);
06035 
06036     
06037     
06038     
06039     virtual ::HxCorba::ImageRep_ptr HxRGB2Intensity(::HxCorba::ImageRep_ptr im);
06040 
06041     
06042     
06043     
06044     virtual ::HxCorba::Histogram_ptr HxGreyEdgeHistogram(::HxCorba::ImageRep_ptr objImage,
06045                                                          CORBA::Double sigma,
06046                                                          CORBA::Double threshold);
06047 
06048     
06049     
06050     
06051     virtual ::HxCorba::Histogram_ptr HxHistogramFromFile(const char* fileName);
06052 
06053     
06054     
06055     
06056     virtual ::HxCorba::Histogram_ptr HxImageToHistogram(::HxCorba::ImageRep_ptr im,
06057                                                         CORBA::Long getDim,
06058                                                         CORBA::Double lowBin,
06059                                                         CORBA::Double highBin,
06060                                                         CORBA::Long nBin);
06061 
06062     
06063     
06064     
06065     virtual ::HxCorba::Histogram_ptr HxImageToHistogramMask(::HxCorba::ImageRep_ptr im,
06066                                                             CORBA::Long getDim,
06067                                                             CORBA::Double lowBin,
06068                                                             CORBA::Double highBin,
06069                                                             CORBA::Long nBin,
06070                                                             ::HxCorba::ImageRep_ptr mask,
06071                                                             CORBA::Long maskVal);
06072 
06073     
06074     
06075     
06076     virtual ::HxCorba::Blob2dSet* HxLabelBlobs(::HxCorba::ImageRep_ptr image,
06077                                                ::HxCorba::ImageRep_ptr mask,
06078                                                CORBA::Long minimalBlobArea);
06079 
06080     
06081     
06082     
06083     virtual ::HxCorba::ImageRep_ptr HxHighlightRegion(::HxCorba::ImageRep_ptr im,
06084                                                       ::HxCorba::ImageRep_ptr mask,
06085                                                       CORBA::Long label,
06086                                                       CORBA::Double factor);
06087 
06088     
06089     
06090     
06091     virtual void HxExportMatlabPixels(::HxCorba::ImageRep_ptr im,
06092                                       ::HxCorba::DoubleSeq& pixels);
06093 
06094     
06095     
06096     
06097     virtual CORBA::Boolean HxWriteFile(::HxCorba::ImageRep_ptr im,
06098                                        const char* fileName);
06099 
06100     
06101     
06102     
06103     virtual CORBA::Boolean HxImagesToFile(const ::HxCorba::ImageList& ims,
06104                                           const char* fileName);
06105 
06106     
06107     
06108     
06109     virtual ::HxCorba::ImageRep_ptr HxCannyEdgeMap(::HxCorba::ImageRep_ptr img,
06110                                                    CORBA::Double sigma);
06111 
06112     
06113     
06114     
06115     virtual ::HxCorba::ImageRep_ptr HxCannyThreshold(::HxCorba::ImageRep_ptr img,
06116                                                      CORBA::Double sigma,
06117                                                      CORBA::Double level);
06118 
06119     
06120     
06121     
06122     virtual ::HxCorba::ImageRep_ptr HxCannyThresholdAlt(::HxCorba::ImageRep_ptr img,
06123                                                         CORBA::Double sigma,
06124                                                         CORBA::Double level);
06125 
06126     
06127     
06128     
06129     virtual ::HxCorba::ImageRep_ptr HxCannyThresholdRec(::HxCorba::ImageRep_ptr img,
06130                                                         CORBA::Double sigma,
06131                                                         CORBA::Double level);
06132 
06133     
06134     
06135     
06136     virtual ::HxCorba::ImageRep_ptr HxConvGauss2d(::HxCorba::ImageRep_ptr img,
06137                                                   CORBA::Double sigmax,
06138                                                   CORBA::Long orderDerivx,
06139                                                   CORBA::Double accuracyx,
06140                                                   CORBA::Double sigmay,
06141                                                   CORBA::Long orderDerivy,
06142                                                   CORBA::Double accuracyy);
06143 
06144     
06145     
06146     
06147     virtual ::HxCorba::ImageRep_ptr HxConvGauss3d(::HxCorba::ImageRep_ptr img,
06148                                                   CORBA::Double sigmax,
06149                                                   CORBA::Long orderDerivx,
06150                                                   CORBA::Double accuracyx,
06151                                                   CORBA::Double sigmay,
06152                                                   CORBA::Long orderDerivy,
06153                                                   CORBA::Double accuracyy,
06154                                                   CORBA::Double sigmaz,
06155                                                   CORBA::Long orderDerivz,
06156                                                   CORBA::Double accuracyz);
06157 
06158     
06159     
06160     
06161     virtual ::HxCorba::ImageRep_ptr HxConvKernelSeparated(::HxCorba::ImageRep_ptr im,
06162                                                           ::HxCorba::ImageRep_ptr kernel,
06163                                                           ::HxCorba::ResultPrecision resPrec);
06164 
06165     
06166     
06167     
06168     virtual ::HxCorba::ImageRep_ptr HxConvKernelSeparated2d(::HxCorba::ImageRep_ptr img,
06169                                                             ::HxCorba::ImageRep_ptr kernelX,
06170                                                             ::HxCorba::ImageRep_ptr kernelY,
06171                                                             ::HxCorba::ResultPrecision resPrec);
06172 
06173     
06174     
06175     
06176     virtual ::HxCorba::ImageRep_ptr HxConvolution(::HxCorba::ImageRep_ptr im,
06177                                                   ::HxCorba::ImageRep_ptr kernel,
06178                                                   ::HxCorba::ResultPrecision resPrec);
06179 
06180     
06181     
06182     
06183     virtual ::HxCorba::ImageRep_ptr HxDefuz(::HxCorba::ImageRep_ptr im,
06184                                             CORBA::Long windowSzX,
06185                                             CORBA::Long windowSzY,
06186                                             CORBA::Double thr);
06187 
06188     
06189     
06190     
06191     virtual ::HxCorba::ImageRep_ptr HxDistanceTransform(::HxCorba::ImageRep_ptr img);
06192 
06193     
06194     
06195     
06196     virtual ::HxCorba::ImageRep_ptr HxGauss(::HxCorba::ImageRep_ptr img,
06197                                             CORBA::Double sigma,
06198                                             CORBA::Double accuracy);
06199 
06200     
06201     
06202     
06203     virtual ::HxCorba::ImageRep_ptr HxGaussDerivative2d(::HxCorba::ImageRep_ptr img,
06204                                                         CORBA::Double sigma,
06205                                                         CORBA::Long orderDerivx,
06206                                                         CORBA::Long orderDerivy,
06207                                                         CORBA::Double accuracy);
06208 
06209     
06210     
06211     
06212     virtual ::HxCorba::ImageRep_ptr HxGaussDerivative3d(::HxCorba::ImageRep_ptr img,
06213                                                         CORBA::Double sigma,
06214                                                         CORBA::Long orderDerivx,
06215                                                         CORBA::Long orderDerivy,
06216                                                         CORBA::Long orderDerivz,
06217                                                         CORBA::Double accuracy);
06218 
06219     
06220     
06221     
06222     virtual ::HxCorba::ImageRep_ptr HxGaussianDeblur(::HxCorba::ImageRep_ptr im,
06223                                                      CORBA::Double dr,
06224                                                      CORBA::Double dc);
06225 
06226     
06227     
06228     
06229     virtual ::HxCorba::ImageRep_ptr HxKuwahara(::HxCorba::ImageRep_ptr im,
06230                                                CORBA::Long width,
06231                                                CORBA::Long height);
06232 
06233     
06234     
06235     
06236     virtual ::HxCorba::ImageRep_ptr HxLocalMode(::HxCorba::ImageRep_ptr f,
06237                                                 ::HxCorba::ImageRep_ptr g,
06238                                                 CORBA::Long nr,
06239                                                 CORBA::Double sigmax,
06240                                                 CORBA::Double sigmay,
06241                                                 CORBA::Double sigmaval,
06242                                                 const ::HxCorba::Sizes& ngbSize);
06243 
06244     
06245     
06246     
06247     virtual ::HxCorba::ImageRep_ptr HxNormalizedCorrelation(::HxCorba::ImageRep_ptr im,
06248                                                             ::HxCorba::ImageRep_ptr kernel);
06249 
06250     
06251     
06252     
06253     virtual ::HxCorba::ImageRep_ptr HxPercentile(::HxCorba::ImageRep_ptr im,
06254                                                  CORBA::Long neighSize,
06255                                                  CORBA::Double perc);
06256 
06257     
06258     
06259     
06260     virtual ::HxCorba::ImageRep_ptr HxRecGabor(::HxCorba::ImageRep_ptr im,
06261                                                CORBA::Double s,
06262                                                CORBA::Double omega0,
06263                                                CORBA::Double theta);
06264 
06265     
06266     
06267     
06268     virtual ::HxCorba::ImageRep_ptr HxRecGauss(::HxCorba::ImageRep_ptr im,
06269                                                CORBA::Double sx,
06270                                                CORBA::Double sy,
06271                                                CORBA::Long dx,
06272                                                CORBA::Long dy,
06273                                                CORBA::Long recurOrder);
06274 
06275     
06276     
06277     
06278     virtual ::HxCorba::ImageRep_ptr HxUniform(::HxCorba::ImageRep_ptr im,
06279                                               const ::HxCorba::Sizes& size);
06280 
06281     
06282     
06283     
06284     virtual ::HxCorba::ImageRep_ptr HxUniformNonSep(::HxCorba::ImageRep_ptr im,
06285                                                     const ::HxCorba::Sizes& size);
06286 
06287     
06288     
06289     
06290     virtual ::HxCorba::ImageRep_ptr HxMakeFrom2Images(::HxCorba::ImageRep_ptr i1,
06291                                                       ::HxCorba::ImageRep_ptr i2);
06292 
06293     
06294     
06295     
06296     virtual ::HxCorba::ImageRep_ptr HxMakeFrom3Images(::HxCorba::ImageRep_ptr i1,
06297                                                       ::HxCorba::ImageRep_ptr i2,
06298                                                       ::HxCorba::ImageRep_ptr i3);
06299 
06300     
06301     
06302     
06303     virtual ::HxCorba::ImageRep_ptr HxMakeFromByteData(CORBA::Long pixelDimensionality,
06304                                                        CORBA::Long dimensions,
06305                                                        const ::HxCorba::Sizes& size,
06306                                                        const ::HxCorba::OctetSeq& data);
06307 
06308     
06309     
06310     
06311     virtual ::HxCorba::ImageRep_ptr HxMakeFromDoubleData(CORBA::Long pixelDimensionality,
06312                                                          CORBA::Long dimensions,
06313                                                          const ::HxCorba::Sizes& size,
06314                                                          const ::HxCorba::DoubleSeq& data);
06315 
06316     
06317     
06318     
06319     virtual ::HxCorba::ImageRep_ptr HxMakeFromFile(const char* fileName);
06320 
06321     
06322     
06323     
06324     virtual ::HxCorba::ImageRep_ptr HxMakeFromFloatData(CORBA::Long pixelDimensionality,
06325                                                         CORBA::Long dimensions,
06326                                                         const ::HxCorba::Sizes& size,
06327                                                         const ::HxCorba::FloatSeq& data);
06328 
06329     
06330     
06331     
06332     virtual ::HxCorba::ImageRep_ptr HxMakeFromGrayValue(::HxCorba::ImageSignature signature,
06333                                                         const ::HxCorba::Sizes& size,
06334                                                         const ::HxCorba::OctetSeq& pixels);
06335 
06336     
06337     
06338     
06339     virtual ::HxCorba::ImageRep_ptr HxMakeFromImage(::HxCorba::ImageSignature signature,
06340                                                     ::HxCorba::ImageRep_ptr src);
06341 
06342     
06343     
06344     
06345     virtual ::HxCorba::ImageRep_ptr HxMakeFromImport(::HxCorba::ImageSignature signature,
06346                                                      const ::HxCorba::Sizes& size,
06347                                                      const char* importOp,
06348                                                      ::HxCorba::TagList_ptr tags);
06349 
06350     
06351     
06352     
06353     virtual ::HxCorba::ImageRep_ptr HxMakeFromIntData(CORBA::Long pixelDimensionality,
06354                                                       CORBA::Long dimensions,
06355                                                       const ::HxCorba::Sizes& size,
06356                                                       const ::HxCorba::LongSeq& data);
06357 
06358     
06359     
06360     
06361     virtual ::HxCorba::ImageRep_ptr HxMakeFromJavaRgb(::HxCorba::ImageSignature signature,
06362                                                       const ::HxCorba::Sizes& size,
06363                                                       const ::HxCorba::LongSeq& pixels);
06364 
06365     
06366     
06367     
06368     virtual ::HxCorba::ImageRep_ptr HxMakeFromMatlab(::HxCorba::ImageSignature signature,
06369                                                      const ::HxCorba::Sizes& size,
06370                                                      const ::HxCorba::DoubleSeq& pixels);
06371 
06372     
06373     
06374     
06375     virtual ::HxCorba::ImageRep_ptr HxMakeFromNamedGenerator(::HxCorba::ImageSignature signature,
06376                                                              const char* generatorName,
06377                                                              ::HxCorba::TagList_ptr tags);
06378 
06379     
06380     
06381     
06382     virtual ::HxCorba::ImageRep_ptr HxMakeFromPpmPixels(::HxCorba::ImageSignature signature,
06383                                                         const ::HxCorba::Sizes& size,
06384                                                         const ::HxCorba::OctetSeq& pixels);
06385 
06386     
06387     
06388     
06389     virtual ::HxCorba::ImageRep_ptr HxMakeFromShortData(CORBA::Long pixelDimensionality,
06390                                                         CORBA::Long dimensions,
06391                                                         const ::HxCorba::Sizes& size,
06392                                                         const ::HxCorba::ShortSeq& data);
06393 
06394     
06395     
06396     
06397     virtual ::HxCorba::ImageRep_ptr HxMakeFromSignature(::HxCorba::ImageSignature signature,
06398                                                         const ::HxCorba::Sizes& size);
06399 
06400     
06401     
06402     
06403     virtual ::HxCorba::ImageRep_ptr HxMakeFromValue(::HxCorba::ImageSignature signature,
06404                                                     const ::HxCorba::Sizes& size,
06405                                                     const ::HxCorba::PixValue& val);
06406 
06407     
06408     
06409     
06410     virtual ::HxCorba::ImageRep_ptr HxMakeGaussian1d(CORBA::Double sigma,
06411                                                      CORBA::Long deri,
06412                                                      CORBA::Double accuracy,
06413                                                      CORBA::Long maxfsize,
06414                                                      CORBA::Long fsize);
06415 
06416     
06417     
06418     
06419     virtual ::HxCorba::ImageRep_ptr HxMakeParabola1d(CORBA::Double rho,
06420                                                      CORBA::Double accuracy,
06421                                                      CORBA::Long maxfsize,
06422                                                      CORBA::Long fsize);
06423 
06424     
06425     
06426     
06427     virtual ::HxCorba::ImageList* HxImagesFromFile(const char* fileName);
06428 
06429     
06430     
06431     
06432     virtual ::HxCorba::ImageRep_ptr HxExtend(::HxCorba::ImageRep_ptr img,
06433                                              ::HxCorba::ImageRep_ptr background,
06434                                              const ::HxCorba::Point& begin);
06435 
06436     
06437     
06438     
06439     virtual ::HxCorba::ImageRep_ptr HxExtendVal(::HxCorba::ImageRep_ptr img,
06440                                                 const ::HxCorba::Sizes& newSize,
06441                                                 const ::HxCorba::PixValue& background,
06442                                                 const ::HxCorba::Point& begin);
06443 
06444     
06445     
06446     
06447     virtual ::HxCorba::ImageRep_ptr HxReflect(::HxCorba::ImageRep_ptr img,
06448                                               CORBA::Long doX,
06449                                               CORBA::Long doY,
06450                                               CORBA::Long doZ);
06451 
06452     
06453     
06454     
06455     virtual ::HxCorba::ImageRep_ptr HxRestrict(::HxCorba::ImageRep_ptr img,
06456                                                const ::HxCorba::Point& begin,
06457                                                const ::HxCorba::Point& end);
06458 
06459     
06460     
06461     
06462     virtual ::HxCorba::ImageRep_ptr HxRotate(::HxCorba::ImageRep_ptr img,
06463                                              CORBA::Double alpha,
06464                                              ::HxCorba::GeoIntType gi,
06465                                              CORBA::Long adjustSize,
06466                                              const ::HxCorba::PixValue& background);
06467 
06468     
06469     
06470     
06471     virtual ::HxCorba::ImageRep_ptr HxScale(::HxCorba::ImageRep_ptr img,
06472                                             CORBA::Double sx,
06473                                             CORBA::Double sy,
06474                                             CORBA::Double sz,
06475                                             ::HxCorba::GeoIntType gi,
06476                                             CORBA::Long adjustSize);
06477 
06478     
06479     
06480     
06481     virtual ::HxCorba::ImageRep_ptr HxTranslate(::HxCorba::ImageRep_ptr img,
06482                                                 CORBA::Long sx,
06483                                                 CORBA::Long sy,
06484                                                 CORBA::Long sz);
06485 
06486     
06487     
06488     
06489     virtual ::HxCorba::ImageRep_ptr HxTranspose(::HxCorba::ImageRep_ptr img);
06490 
06491     
06492     
06493     
06494     virtual CORBA::Long HxImageMaxSize(::HxCorba::ImageRep_ptr img);
06495 
06496     
06497     
06498     
06499     virtual CORBA::Long HxImageMinSize(::HxCorba::ImageRep_ptr img);
06500 
06501     
06502     
06503     
06504     virtual ::HxCorba::PixValue HxIdentMaskMean(::HxCorba::ImageRep_ptr im,
06505                                                 ::HxCorba::ImageRep_ptr mask,
06506                                                 const ::HxCorba::Point& p,
06507                                                 const ::HxCorba::Sizes& size,
06508                                                 CORBA::Long label);
06509 
06510     
06511     
06512     
06513     virtual ::HxCorba::PixValue HxIdentMaskMedian(::HxCorba::ImageRep_ptr im,
06514                                                   ::HxCorba::ImageRep_ptr mask,
06515                                                   const ::HxCorba::Point& p,
06516                                                   const ::HxCorba::Sizes& size,
06517                                                   CORBA::Long label);
06518 
06519     
06520     
06521     
06522     virtual ::HxCorba::PixValue HxIdentMaskStDev(::HxCorba::ImageRep_ptr im,
06523                                                  ::HxCorba::ImageRep_ptr mask,
06524                                                  const ::HxCorba::Point& p,
06525                                                  const ::HxCorba::Sizes& size,
06526                                                  CORBA::Long label);
06527 
06528     
06529     
06530     
06531     virtual ::HxCorba::PixValue HxIdentMaskSum(::HxCorba::ImageRep_ptr im,
06532                                                ::HxCorba::ImageRep_ptr mask,
06533                                                const ::HxCorba::Point& p,
06534                                                const ::HxCorba::Sizes& size,
06535                                                CORBA::Long label);
06536 
06537     
06538     
06539     
06540     virtual ::HxCorba::PixValue HxIdentMaskVariance(::HxCorba::ImageRep_ptr im,
06541                                                     ::HxCorba::ImageRep_ptr mask,
06542                                                     const ::HxCorba::Point& p,
06543                                                     const ::HxCorba::Sizes& size,
06544                                                     CORBA::Long label);
06545 
06546     
06547     
06548     
06549     virtual ::HxCorba::PixValue HxWeightMaskSum(::HxCorba::ImageRep_ptr im,
06550                                                 ::HxCorba::ImageRep_ptr mask,
06551                                                 const ::HxCorba::Point& p);
06552 
06553     
06554     
06555     
06556     virtual ::HxCorba::ImageRep_ptr HxAreaClosing(::HxCorba::ImageRep_ptr im,
06557                                                   CORBA::Long conn,
06558                                                   CORBA::Long minarea);
06559 
06560     
06561     
06562     
06563     virtual ::HxCorba::ImageRep_ptr HxAreaOpening(::HxCorba::ImageRep_ptr im,
06564                                                   CORBA::Long conn,
06565                                                   CORBA::Long area);
06566 
06567     
06568     
06569     
06570     virtual ::HxCorba::ImageRep_ptr HxClosing(::HxCorba::ImageRep_ptr im,
06571                                               ::HxCorba::SF_ptr s);
06572 
06573     
06574     
06575     
06576     virtual ::HxCorba::ImageRep_ptr HxClosingByReconstruction(::HxCorba::ImageRep_ptr im,
06577                                                               ::HxCorba::SF_ptr s1,
06578                                                               ::HxCorba::SF_ptr s2);
06579 
06580     
06581     
06582     
06583     virtual ::HxCorba::ImageRep_ptr HxClosingByReconstructionTopHat(::HxCorba::ImageRep_ptr im,
06584                                                                     ::HxCorba::SF_ptr s1,
06585                                                                     ::HxCorba::SF_ptr s2);
06586 
06587     
06588     
06589     
06590     virtual ::HxCorba::ImageRep_ptr HxClosingTopHat(::HxCorba::ImageRep_ptr im,
06591                                                     ::HxCorba::SF_ptr s);
06592 
06593     
06594     
06595     
06596     virtual ::HxCorba::ImageRep_ptr HxConditionalDilation(::HxCorba::ImageRep_ptr im,
06597                                                           ::HxCorba::ImageRep_ptr mask,
06598                                                           ::HxCorba::SF_ptr s,
06599                                                           CORBA::Long nrIter);
06600 
06601     
06602     
06603     
06604     virtual ::HxCorba::ImageRep_ptr HxConditionalErosion(::HxCorba::ImageRep_ptr im,
06605                                                          ::HxCorba::ImageRep_ptr mask,
06606                                                          ::HxCorba::SF_ptr s,
06607                                                          CORBA::Long nrIter);
06608 
06609     
06610     
06611     
06612     virtual ::HxCorba::ImageRep_ptr HxDilation(::HxCorba::ImageRep_ptr im,
06613                                                ::HxCorba::SF_ptr s);
06614 
06615     
06616     
06617     
06618     virtual ::HxCorba::ImageRep_ptr HxDistanceTransformMM(::HxCorba::ImageRep_ptr im,
06619                                                           ::HxCorba::SF_ptr s);
06620 
06621     
06622     
06623     
06624     virtual ::HxCorba::ImageRep_ptr HxErosion(::HxCorba::ImageRep_ptr im,
06625                                               ::HxCorba::SF_ptr s);
06626 
06627     
06628     
06629     
06630     virtual ::HxCorba::ImageRep_ptr HxGeodesicDistanceTransform(::HxCorba::ImageRep_ptr im,
06631                                                                 CORBA::Long conn);
06632 
06633     
06634     
06635     
06636     virtual ::HxCorba::ImageRep_ptr HxHilditchSkeleton(::HxCorba::ImageRep_ptr im);
06637 
06638     
06639     
06640     
06641     virtual ::HxCorba::ImageRep_ptr HxHitOrMiss(::HxCorba::ImageRep_ptr im,
06642                                                 ::HxCorba::SF_ptr s1,
06643                                                 ::HxCorba::SF_ptr s2);
06644 
06645     
06646     
06647     
06648     virtual ::HxCorba::ImageRep_ptr HxInfimumReconstruction(::HxCorba::ImageRep_ptr im,
06649                                                             ::HxCorba::ImageRep_ptr mask,
06650                                                             ::HxCorba::SF_ptr s);
06651 
06652     
06653     
06654     
06655     virtual ::HxCorba::ImageRep_ptr HxMorphologicalContour(::HxCorba::ImageRep_ptr im,
06656                                                            ::HxCorba::SF_ptr s);
06657 
06658     
06659     
06660     
06661     virtual ::HxCorba::ImageRep_ptr HxMorphologicalGradient(::HxCorba::ImageRep_ptr im,
06662                                                             ::HxCorba::SF_ptr s);
06663 
06664     
06665     
06666     
06667     virtual ::HxCorba::ImageRep_ptr HxMorphologicalGradient2(::HxCorba::ImageRep_ptr im,
06668                                                              ::HxCorba::SF_ptr s1,
06669                                                              ::HxCorba::SF_ptr s2);
06670 
06671     
06672     
06673     
06674     virtual ::HxCorba::ImageRep_ptr HxOpening(::HxCorba::ImageRep_ptr im,
06675                                               ::HxCorba::SF_ptr s);
06676 
06677     
06678     
06679     
06680     virtual ::HxCorba::ImageRep_ptr HxOpeningByReconstruction(::HxCorba::ImageRep_ptr im,
06681                                                               ::HxCorba::SF_ptr s1,
06682                                                               ::HxCorba::SF_ptr s2);
06683 
06684     
06685     
06686     
06687     virtual ::HxCorba::ImageRep_ptr HxOpeningByReconstructionTopHat(::HxCorba::ImageRep_ptr im,
06688                                                                     ::HxCorba::SF_ptr s1,
06689                                                                     ::HxCorba::SF_ptr s2);
06690 
06691     
06692     
06693     
06694     virtual ::HxCorba::ImageRep_ptr HxOpeningTopHat(::HxCorba::ImageRep_ptr im,
06695                                                     ::HxCorba::SF_ptr s);
06696 
06697     
06698     
06699     
06700     virtual ::HxCorba::ImageRep_ptr HxParabolicDilation(::HxCorba::ImageRep_ptr img,
06701                                                         CORBA::Double rho,
06702                                                         CORBA::Double accuracy);
06703 
06704     
06705     
06706     
06707     virtual ::HxCorba::ImageRep_ptr HxParabolicErosion(::HxCorba::ImageRep_ptr img,
06708                                                        CORBA::Double rho,
06709                                                        CORBA::Double accuracy);
06710 
06711     
06712     
06713     
06714     virtual ::HxCorba::ImageRep_ptr HxPeakRemoval(::HxCorba::ImageRep_ptr im,
06715                                                   CORBA::Long conn,
06716                                                   CORBA::Long minarea);
06717 
06718     
06719     
06720     
06721     virtual ::HxCorba::ImageRep_ptr HxRegionalMaxima(::HxCorba::ImageRep_ptr im,
06722                                                      CORBA::Long conn);
06723 
06724     
06725     
06726     
06727     virtual ::HxCorba::ImageRep_ptr HxRegionalMinima(::HxCorba::ImageRep_ptr im,
06728                                                      CORBA::Long conn);
06729 
06730     
06731     
06732     
06733     virtual ::HxCorba::ImageRep_ptr HxSKIZ(::HxCorba::ImageRep_ptr im,
06734                                            CORBA::Long conn);
06735 
06736     
06737     
06738     
06739     virtual ::HxCorba::ImageRep_ptr HxSkeleton(::HxCorba::ImageRep_ptr im,
06740                                                ::HxCorba::SF_ptr s);
06741 
06742     
06743     
06744     
06745     virtual ::HxCorba::ImageRep_ptr HxSupremumReconstruction(::HxCorba::ImageRep_ptr im,
06746                                                              ::HxCorba::ImageRep_ptr mask,
06747                                                              ::HxCorba::SF_ptr s);
06748 
06749     
06750     
06751     
06752     virtual ::HxCorba::ImageRep_ptr HxThickening(::HxCorba::ImageRep_ptr im,
06753                                                  ::HxCorba::SF_ptr s1,
06754                                                  ::HxCorba::SF_ptr s2);
06755 
06756     
06757     
06758     
06759     virtual ::HxCorba::ImageRep_ptr HxThinning(::HxCorba::ImageRep_ptr im,
06760                                                ::HxCorba::SF_ptr s1,
06761                                                ::HxCorba::SF_ptr s2);
06762 
06763     
06764     
06765     
06766     virtual ::HxCorba::ImageRep_ptr HxValleyRemoval(::HxCorba::ImageRep_ptr im,
06767                                                     CORBA::Long conn,
06768                                                     CORBA::Long minarea);
06769 
06770     
06771     
06772     
06773     virtual ::HxCorba::ImageRep_ptr HxWatershed(::HxCorba::ImageRep_ptr im,
06774                                                 CORBA::Long conn);
06775 
06776     
06777     
06778     
06779     virtual ::HxCorba::ImageRep_ptr HxWatershedMarkers(::HxCorba::ImageRep_ptr input,
06780                                                        ::HxCorba::ImageRep_ptr mask,
06781                                                        CORBA::Long conn,
06782                                                        CORBA::Boolean doLabelMask);
06783 
06784     
06785     
06786     
06787     virtual ::HxCorba::ImageRep_ptr HxWatershedMarkers2(::HxCorba::ImageRep_ptr input,
06788                                                         ::HxCorba::ImageRep_ptr mask,
06789                                                         CORBA::Long conn,
06790                                                         CORBA::Boolean doLabelMask,
06791                                                         CORBA::Long costMethod);
06792 
06793     
06794     
06795     
06796     virtual ::HxCorba::ImageRep_ptr HxWatershedSlow(::HxCorba::ImageRep_ptr im,
06797                                                     ::HxCorba::SF_ptr s,
06798                                                     const char* linereg);
06799 
06800     
06801     
06802     
06803     virtual ::HxCorba::ImageRep_ptr HxDisplayOF(::HxCorba::ImageRep_ptr im,
06804                                                 CORBA::Long scale_x,
06805                                                 CORBA::Long scale_y,
06806                                                 CORBA::Double mul_x,
06807                                                 CORBA::Double mul_y,
06808                                                 CORBA::Long pixelsize);
06809 
06810     
06811     
06812     
06813     virtual ::HxCorba::ImageRep_ptr HxOpticalFlow(::HxCorba::ImageRep_ptr im1,
06814                                                   ::HxCorba::ImageRep_ptr im2);
06815 
06816     
06817     
06818     
06819     virtual ::HxCorba::ImageRep_ptr HxOpticalFlowMultiScale(::HxCorba::ImageRep_ptr im1,
06820                                                             ::HxCorba::ImageRep_ptr im2);
06821 
06822     
06823     
06824     
06825     virtual ::HxCorba::ImageRep_ptr HxAddBinaryNoise(::HxCorba::ImageRep_ptr im,
06826                                                      CORBA::Double percent);
06827 
06828     
06829     
06830     
06831     virtual ::HxCorba::ImageRep_ptr HxAddGaussianNoise(::HxCorba::ImageRep_ptr im,
06832                                                        CORBA::Double mean,
06833                                                        CORBA::Double stdev);
06834 
06835     
06836     
06837     
06838     virtual ::HxCorba::ImageRep_ptr HxAddPoissonNoise(::HxCorba::ImageRep_ptr im,
06839                                                       CORBA::Double conversionFactor);
06840 
06841     
06842     
06843     
06844     virtual ::HxCorba::ImageRep_ptr HxAddUniformNoise(::HxCorba::ImageRep_ptr im);
06845 
06846     
06847     
06848     
06849     virtual ::HxCorba::ImageRep_ptr HxContrastStretch(::HxCorba::ImageRep_ptr im,
06850                                                       CORBA::Double val);
06851 
06852     
06853     
06854     
06855     virtual ::HxCorba::ImageRep_ptr HxSetBorderValue(::HxCorba::ImageRep_ptr im,
06856                                                      CORBA::Long w,
06857                                                      CORBA::Long h,
06858                                                      const ::HxCorba::PixValue& val);
06859 
06860     
06861     
06862     
06863     virtual ::HxCorba::ImageRep_ptr HxSetPartImage(::HxCorba::ImageRep_ptr im,
06864                                                    CORBA::Long x1,
06865                                                    CORBA::Long y1,
06866                                                    CORBA::Long x2,
06867                                                    CORBA::Long y2,
06868                                                    const ::HxCorba::PixValue& val);
06869 
06870     
06871     
06872     
06873     virtual ::HxCorba::ImageRep_ptr HxSquaredDistance(::HxCorba::ImageRep_ptr im1,
06874                                                       ::HxCorba::ImageRep_ptr im2);
06875 
06876     
06877     
06878     
06879     virtual ::HxCorba::ImageRep_ptr HxBernsenThreshold(::HxCorba::ImageRep_ptr im,
06880                                                        CORBA::Long windowSz,
06881                                                        CORBA::Long uniformTh,
06882                                                        CORBA::Boolean uniformLow);
06883 
06884     
06885     
06886     
06887     virtual ::HxCorba::ImageRep_ptr HxColorGaborSegmentation(::HxCorba::ImageRep_ptr im,
06888                                                              ::HxCorba::ColorGaborSegmentationAlgorithm segAlg,
06889                                                              ::HxCorba::ColorGaborSegmentationInvariant invariantType,
06890                                                              CORBA::Double minRegionFraction,
06891                                                              CORBA::Double threshold);
06892 
06893     
06894     
06895     
06896     virtual ::HxCorba::ImageRep_ptr HxEntropyThreshold(::HxCorba::ImageRep_ptr im);
06897 
06898     
06899     
06900     
06901     virtual ::HxCorba::ImageRep_ptr HxIsodataThreshold(::HxCorba::ImageRep_ptr im);
06902 
06903     
06904     
06905     
06906     virtual ::HxCorba::ImageRep_ptr HxLabel(::HxCorba::ImageRep_ptr im,
06907                                             CORBA::Long conn);
06908 
06909     
06910     
06911     
06912     virtual ::HxCorba::ImageRep_ptr HxLabel2(::HxCorba::ImageRep_ptr im,
06913                                              CORBA::Long conn);
06914 
06915     
06916     
06917     
06918     virtual ::HxCorba::ImageRep_ptr HxThreshold(::HxCorba::ImageRep_ptr im,
06919                                                 const ::HxCorba::PixValue& val);
06920 
06921     
06922     
06923     
06924     virtual ::HxCorba::ImageRep_ptr HxTriStateThreshold(::HxCorba::ImageRep_ptr im,
06925                                                         const ::HxCorba::PixValue& level,
06926                                                         const ::HxCorba::PixValue& v1,
06927                                                         const ::HxCorba::PixValue& v2,
06928                                                         const ::HxCorba::PixValue& v3);
06929 
06930     
06931     
06932     
06933     virtual CORBA::Boolean VxRelEquals(const ::HxCorba::VxTimeSpan& elt1,
06934                                        const ::HxCorba::VxTimeSpan& elt2);
06935 
06936     
06937     
06938     
06939     virtual CORBA::Boolean VxRelMeets(const ::HxCorba::VxTimeSpan& elt1,
06940                                       const ::HxCorba::VxTimeSpan& elt2);
06941 
06942     
06943     
06944     
06945     virtual CORBA::Boolean VxRelBefore(const ::HxCorba::VxTimeSpan& elt1,
06946                                        const ::HxCorba::VxTimeSpan& elt2);
06947 
06948     
06949     
06950     
06951     virtual CORBA::Boolean VxRelOverlaps(const ::HxCorba::VxTimeSpan& elt1,
06952                                          const ::HxCorba::VxTimeSpan& elt2);
06953 
06954     
06955     
06956     
06957     virtual CORBA::Boolean VxRelDur(const ::HxCorba::VxTimeSpan& elt1,
06958                                     const ::HxCorba::VxTimeSpan& elt2);
06959 
06960     
06961     
06962     
06963     virtual CORBA::Boolean VxRelCon(const ::HxCorba::VxTimeSpan& elt1,
06964                                     const ::HxCorba::VxTimeSpan& elt2);
06965 
06966     
06967     
06968     
06969     virtual CORBA::Boolean VxRelMeetsAnywhere(const ::HxCorba::VxTimeSpan& elt1,
06970                                               const ::HxCorba::VxTimeSpan& elt2);
06971 
06972     
06973     
06974     
06975     virtual CORBA::Boolean VxRelBeforeAfter(const ::HxCorba::VxTimeSpan& elt1,
06976                                             const ::HxCorba::VxTimeSpan& elt2);
06977 
06978     
06979     
06980     
06981     virtual CORBA::Boolean VxRelOverlapsAnywhere(const ::HxCorba::VxTimeSpan& elt1,
06982                                                  const ::HxCorba::VxTimeSpan& elt2);
06983 
06984     
06985     
06986     
06987     virtual char* VxRelAsString(const ::HxCorba::VxTimeSpan& elt1,
06988                                 const ::HxCorba::VxTimeSpan& elt2);
06989 
06990     
06991     
06992     
06993     virtual void HxIDBOpen(const char* name,
06994                            const char* indexFile);
06995 
06996     
06997     
06998     
06999     virtual ::HxCorba::StringSeq* HxIDBRandom(const char* name,
07000                                               CORBA::Long n);
07001 
07002     
07003     
07004     
07005     virtual ::HxCorba::StringSeq* HxIDBSearch(const char* key,
07006                                               const char* name,
07007                                               CORBA::Long n);
07008 
07009     
07010     
07011     
07012     virtual void HxInvarOpenDB(const char* indexFile,
07013                                const char* dbDir);
07014 
07015     
07016     
07017     
07018     virtual ::HxCorba::StringSeq* HxInvarRandom(const char* invar,
07019                                                 CORBA::Long n);
07020 
07021     
07022     
07023     
07024     virtual ::HxCorba::StringSeq* HxInvarSearch(::HxCorba::ImageRep_ptr im,
07025                                                 const char* invar,
07026                                                 CORBA::Long n);
07027 
07028     
07029     
07030     
07031     virtual ::HxCorba::StringSeq* HxInvarSearchHisto(const ::HxCorba::HistogramList& target,
07032                                                      const char* invar,
07033                                                      CORBA::Long n);
07034 
07035     
07036     
07037     
07038     virtual CORBA::Double HxInvarMatchHistos(const ::HxCorba::HistogramList& l1,
07039                                              const ::HxCorba::HistogramList& l2);
07040 
07041     
07042     
07043     
07044     virtual void HxInvarIndexDB(const char* indexFile,
07045                                 const char* dbDir,
07046                                 const char* invar,
07047                                 CORBA::Double s,
07048                                 CORBA::Long bins);
07049 
07050     
07051     
07052     
07053     virtual CORBA::Long HxInvarDBSize(const char* invar);
07054 
07055     
07056     
07057     
07058     virtual CORBA::Long HxInvarBinsPerHistogram(const char* invar);
07059 
07060     
07061     
07062     
07063     virtual CORBA::Long HxInvarChannels(const char* invar);
07064 
07065     
07066     
07067     
07068     virtual ::HxCorba::StringSeq* HxInvarDBList(const char* invar);
07069 
07070     
07071     
07072     
07073     virtual ::HxCorba::FloatSeq* HxInvarGetHistos(const char* invar,
07074                                                   const char* key);
07075 
07076     
07077     
07078     
07079     virtual ::HxCorba::StringSeq* HxInvarSearchKey(const char* key,
07080                                                    const char* invar,
07081                                                    CORBA::Long n);
07082 
07083     
07084     
07085     
07086     virtual ::HxCorba::DoubleSeq* HxInvarScores(const char* invar,
07087                                                 CORBA::Long n);
07088 
07089     
07090     
07091     
07092     virtual ::HxCorba::ImageRep_ptr HxNJetInvarE(::HxCorba::NJet_ptr nj);
07093 
07094     
07095     
07096     
07097     virtual ::HxCorba::ImageRep_ptr HxNJetInvarC(::HxCorba::NJet_ptr nj);
07098 
07099     
07100     
07101     
07102     virtual ::HxCorba::ImageRep_ptr HxNJetInvarWw(::HxCorba::NJet_ptr nj);
07103 
07104     
07105     
07106     
07107     virtual ::HxCorba::ImageRep_ptr HxNJetInvarCw(::HxCorba::NJet_ptr nj);
07108 
07109     
07110     
07111     
07112     virtual ::HxCorba::HistogramList* HxNJetInvarEHisto(::HxCorba::NJet_ptr nj,
07113                                                         CORBA::Long nBin);
07114 
07115     
07116     
07117     
07118     virtual ::HxCorba::HistogramList* HxNJetInvarCHisto(::HxCorba::NJet_ptr nj,
07119                                                         CORBA::Long nBin);
07120 
07121     
07122     
07123     
07124     virtual ::HxCorba::HistogramList* HxNJetInvarWwHisto(::HxCorba::NJet_ptr nj,
07125                                                          CORBA::Long nBin);
07126 
07127     
07128     
07129     
07130     virtual ::HxCorba::HistogramList* HxNJetInvarCwHisto(::HxCorba::NJet_ptr nj,
07131                                                          CORBA::Long nBin);
07132 
07133     
07134     
07135     
07136     virtual ::HxCorba::HistogramList* HxInvarEHisto(::HxCorba::ImageRep_ptr im,
07137                                                     CORBA::Double scale,
07138                                                     CORBA::Long nBin);
07139 
07140     
07141     
07142     
07143     virtual ::HxCorba::HistogramList* HxInvarCHisto(::HxCorba::ImageRep_ptr im,
07144                                                     CORBA::Double scale,
07145                                                     CORBA::Long nBin);
07146 
07147     
07148     
07149     
07150     virtual ::HxCorba::HistogramList* HxInvarWwHisto(::HxCorba::ImageRep_ptr im,
07151                                                      CORBA::Double scale,
07152                                                      CORBA::Long nBin);
07153 
07154     
07155     
07156     
07157     virtual ::HxCorba::HistogramList* HxInvarCwHisto(::HxCorba::ImageRep_ptr im,
07158                                                      CORBA::Double scale,
07159                                                      CORBA::Long nBin);
07160 
07161     
07162     
07163     
07164     virtual ::HxCorba::DoubleSeqSeq* HxNJetInvar(::HxCorba::ImageRep_ptr im,
07165                                                  const char* invar,
07166                                                  CORBA::Double scale,
07167                                                  CORBA::Long nBin);
07168 
07169     
07170     
07171     
07172     virtual ::HxCorba::ImageRep_ptr HxColorInvarEw(::HxCorba::ImageRep_ptr im,
07173                                                    CORBA::Double scale);
07174 
07175     
07176     
07177     
07178     virtual ::HxCorba::ImageRep_ptr HxColorInvarWw(::HxCorba::ImageRep_ptr im,
07179                                                    CORBA::Double scale);
07180 
07181     
07182     
07183     
07184     virtual ::HxCorba::ImageRep_ptr HxColorInvarCw(::HxCorba::ImageRep_ptr im,
07185                                                    CORBA::Double scale);
07186 
07187     
07188     
07189     
07190     virtual ::HxCorba::ImageRep_ptr HxColorInvarNw(::HxCorba::ImageRep_ptr im,
07191                                                    CORBA::Double scale);
07192 
07193     
07194     
07195     
07196     virtual ::HxCorba::ImageRep_ptr HxColorInvarHw(::HxCorba::ImageRep_ptr im,
07197                                                    CORBA::Double scale);
07198 };
07199 
07200 } 
07201 
07202 
07203 
07204 
07205 namespace OBV_HxCorba
07206 {
07207 
07208 } 
07209 
07210 
07211 
07212 
07213 void operator<<=(CORBA::Any&, HxCorba::ColorModel);
07214 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ColorModel&);
07215 
07216 inline void
07217 operator<<=(CORBA::Any_var& any, HxCorba::ColorModel val)
07218 {
07219     any.inout() <<= val;
07220 }
07221 
07222 inline CORBA::Boolean
07223 operator>>=(const CORBA::Any_var& any, HxCorba::ColorModel& val)
07224 {
07225     return any.in() >>= val;
07226 }
07227 
07228 
07229 
07230 
07231 void operator<<=(CORBA::Any&, HxCorba::ColorGaborSegmentationInvariant);
07232 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ColorGaborSegmentationInvariant&);
07233 
07234 inline void
07235 operator<<=(CORBA::Any_var& any, HxCorba::ColorGaborSegmentationInvariant val)
07236 {
07237     any.inout() <<= val;
07238 }
07239 
07240 inline CORBA::Boolean
07241 operator>>=(const CORBA::Any_var& any, HxCorba::ColorGaborSegmentationInvariant& val)
07242 {
07243     return any.in() >>= val;
07244 }
07245 
07246 
07247 
07248 
07249 void operator<<=(CORBA::Any&, HxCorba::ColorGaborSegmentationAlgorithm);
07250 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ColorGaborSegmentationAlgorithm&);
07251 
07252 inline void
07253 operator<<=(CORBA::Any_var& any, HxCorba::ColorGaborSegmentationAlgorithm val)
07254 {
07255     any.inout() <<= val;
07256 }
07257 
07258 inline CORBA::Boolean
07259 operator>>=(const CORBA::Any_var& any, HxCorba::ColorGaborSegmentationAlgorithm& val)
07260 {
07261     return any.in() >>= val;
07262 }
07263 
07264 
07265 
07266 
07267 namespace CORBA
07268 {
07269 
07270 inline void
07271 release(::HxCorba::GlobalOps_ptr p)
07272 {
07273     if(p)
07274         p -> _remove_ref();
07275 }
07276 
07277 inline Boolean
07278 is_nil(::HxCorba::GlobalOps_ptr p)
07279 {
07280     return p == 0;
07281 }
07282 
07283 inline void
07284 release(OBStubImpl_HxCorba::GlobalOps_ptr p)
07285 {
07286     if(p)
07287         p -> _OB_decRef();
07288 }
07289 
07290 inline Boolean
07291 is_nil(OBStubImpl_HxCorba::GlobalOps_ptr p)
07292 {
07293     return p == 0;
07294 }
07295 
07296 } 
07297 
07298 void operator<<=(CORBA::Any&, HxCorba::GlobalOps_ptr*);
07299 void operator<<=(CORBA::Any&, HxCorba::GlobalOps_ptr);
07300 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::GlobalOps_ptr&);
07301 
07302 inline void
07303 operator<<=(CORBA::Any_var& any, HxCorba::GlobalOps_ptr* val)
07304 {
07305     any.inout() <<= val;
07306 }
07307 
07308 inline void
07309 operator<<=(CORBA::Any_var& any, HxCorba::GlobalOps_ptr val)
07310 {
07311     any.inout() <<= val;
07312 }
07313 
07314 inline CORBA::Boolean
07315 operator>>=(const CORBA::Any_var& any, HxCorba::GlobalOps_ptr& val)
07316 {
07317     return any.in() >>= val;
07318 }
07319 
07320 #endif