00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef ___HxCorbaImageRep_h__
00016 #define ___HxCorbaImageRep_h__
00017
00018 #include <HxCorbaTagList.h>
00019 #include <HxCorbaTypes.h>
00020 #include <HxCorbaRgbBuffer.h>
00021 #include <HxCorbaMatrix.h>
00022 #include <HxCorbaRefCountBase.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 ImageRepRgbSource;
00038 typedef ImageRepRgbSource* ImageRepRgbSource_ptr;
00039 typedef ImageRepRgbSource* ImageRepRgbSourceRef;
00040
00041 extern OB::TypeCodeConst _tc_ImageRepRgbSource;
00042
00043 class ImageData;
00044 typedef ImageData* ImageData_ptr;
00045 typedef ImageData* ImageDataRef;
00046
00047 extern OB::TypeCodeConst _tc_ImageData;
00048
00049 class ImageRep;
00050 typedef ImageRep* ImageRep_ptr;
00051 typedef ImageRep* ImageRepRef;
00052
00053 extern OB::TypeCodeConst _tc_ImageRep;
00054
00055 class ImageFactory;
00056 typedef ImageFactory* ImageFactory_ptr;
00057 typedef ImageFactory* ImageFactoryRef;
00058
00059 extern OB::TypeCodeConst _tc_ImageFactory;
00060
00061 }
00062
00063 void OBDuplicate(HxCorba::ImageRepRgbSource_ptr);
00064 void OBRelease(HxCorba::ImageRepRgbSource_ptr);
00065
00066 void OBMarshal(HxCorba::ImageRepRgbSource_ptr, OB::OutputStreamImpl*);
00067 void OBUnmarshal(HxCorba::ImageRepRgbSource_ptr&, OB::InputStreamImpl*);
00068
00069 void OBDuplicate(HxCorba::ImageData_ptr);
00070 void OBRelease(HxCorba::ImageData_ptr);
00071
00072 void OBMarshal(HxCorba::ImageData_ptr, OB::OutputStreamImpl*);
00073 void OBUnmarshal(HxCorba::ImageData_ptr&, OB::InputStreamImpl*);
00074
00075 void OBDuplicate(HxCorba::ImageRep_ptr);
00076 void OBRelease(HxCorba::ImageRep_ptr);
00077
00078 void OBMarshal(HxCorba::ImageRep_ptr, OB::OutputStreamImpl*);
00079 void OBUnmarshal(HxCorba::ImageRep_ptr&, OB::InputStreamImpl*);
00080
00081 void OBDuplicate(HxCorba::ImageFactory_ptr);
00082 void OBRelease(HxCorba::ImageFactory_ptr);
00083
00084 void OBMarshal(HxCorba::ImageFactory_ptr, OB::OutputStreamImpl*);
00085 void OBUnmarshal(HxCorba::ImageFactory_ptr&, OB::InputStreamImpl*);
00086
00087 namespace HxCorba
00088 {
00089
00090 typedef OB::ObjVar< ImageRepRgbSource > ImageRepRgbSource_var;
00091 typedef OB::ObjOut< ImageRepRgbSource > ImageRepRgbSource_out;
00092
00093 typedef OB::ObjVar< ImageData > ImageData_var;
00094 typedef OB::ObjOut< ImageData > ImageData_out;
00095
00096 typedef OB::ObjVar< ImageRep > ImageRep_var;
00097 typedef OB::ObjOut< ImageRep > ImageRep_out;
00098
00099 typedef OB::ObjVar< ImageFactory > ImageFactory_var;
00100 typedef OB::ObjOut< ImageFactory > ImageFactory_out;
00101
00102 }
00103
00104 namespace OBStubImpl_HxCorba
00105 {
00106
00107 class ImageRepRgbSource;
00108 typedef ImageRepRgbSource* ImageRepRgbSource_ptr;
00109
00110 class ImageData;
00111 typedef ImageData* ImageData_ptr;
00112
00113 class ImageRep;
00114 typedef ImageRep* ImageRep_ptr;
00115
00116 class ImageFactory;
00117 typedef ImageFactory* ImageFactory_ptr;
00118
00119 }
00120
00121 void OBDuplicate(OBStubImpl_HxCorba::ImageRepRgbSource_ptr);
00122 void OBRelease(OBStubImpl_HxCorba::ImageRepRgbSource_ptr);
00123
00124 void OBDuplicate(OBStubImpl_HxCorba::ImageData_ptr);
00125 void OBRelease(OBStubImpl_HxCorba::ImageData_ptr);
00126
00127 void OBDuplicate(OBStubImpl_HxCorba::ImageRep_ptr);
00128 void OBRelease(OBStubImpl_HxCorba::ImageRep_ptr);
00129
00130 void OBDuplicate(OBStubImpl_HxCorba::ImageFactory_ptr);
00131 void OBRelease(OBStubImpl_HxCorba::ImageFactory_ptr);
00132
00133 namespace OBStubImpl_HxCorba
00134 {
00135
00136 typedef OB::ObjVar< ImageRepRgbSource > ImageRepRgbSource_var;
00137
00138 typedef OB::ObjVar< ImageData > ImageData_var;
00139
00140 typedef OB::ObjVar< ImageRep > ImageRep_var;
00141
00142 typedef OB::ObjVar< ImageFactory > ImageFactory_var;
00143
00144 }
00145
00146
00147
00148
00149 namespace HxCorba
00150 {
00151
00152
00153
00154
00155 enum PixelT
00156 {
00157 INT_VALUE,
00158 REAL_VALUE,
00159 COMPLEX_VALUE
00160 };
00161
00162 typedef PixelT& PixelT_out;
00163
00164 extern OB::TypeCodeConst _tc_PixelT;
00165
00166
00167
00168
00169 enum ImageSignature
00170 {
00171 SIG2DBYTE,
00172 SIG2DSHORT,
00173 SIG2DINT,
00174 SIG2DFLOAT,
00175 SIG2DDOUBLE,
00176 SIG2DVEC2BYTE,
00177 SIG2DVEC2SHORT,
00178 SIG2DVEC2INT,
00179 SIG2DVEC2FLOAT,
00180 SIG2DVEC2DOUBLE,
00181 SIG2DVEC3BYTE,
00182 SIG2DVEC3SHORT,
00183 SIG2DVEC3INT,
00184 SIG2DVEC3FLOAT,
00185 SIG2DVEC3DOUBLE,
00186 SIG2DCOMPLEX
00187 };
00188
00189 typedef ImageSignature& ImageSignature_out;
00190
00191 extern OB::TypeCodeConst _tc_ImageSignature;
00192
00193
00194
00195
00196 struct Sizes;
00197 typedef OB::FixVar< Sizes > Sizes_var;
00198 typedef Sizes& Sizes_out;
00199
00200 struct Sizes
00201 {
00202 typedef Sizes_var _var_type;
00203
00204 CORBA::Long x;
00205 CORBA::Long y;
00206 CORBA::Long z;
00207
00208 void _OB_marshal(OB::OutputStreamImpl*) const;
00209 static void _OB_unmarshal(Sizes&, OB::InputStreamImpl*);
00210 };
00211
00212 extern OB::TypeCodeConst _tc_Sizes;
00213
00214
00215
00216
00217 struct Point;
00218 typedef OB::FixVar< Point > Point_var;
00219 typedef Point& Point_out;
00220
00221 struct Point
00222 {
00223 typedef Point_var _var_type;
00224
00225 CORBA::Double x;
00226 CORBA::Double y;
00227 CORBA::Double z;
00228
00229 void _OB_marshal(OB::OutputStreamImpl*) const;
00230 static void _OB_unmarshal(Point&, OB::InputStreamImpl*);
00231 };
00232
00233 extern OB::TypeCodeConst _tc_Point;
00234
00235
00236
00237
00238 class ImageRepRgbSource : virtual public ::HxCorba::RgbSource
00239 {
00240 ImageRepRgbSource(const ImageRepRgbSource&);
00241 void operator=(const ImageRepRgbSource&);
00242
00243 protected:
00244
00245 static const char* ids_[];
00246
00247 public:
00248
00249 ImageRepRgbSource() { }
00250 virtual ~ImageRepRgbSource() { }
00251
00252 typedef ImageRepRgbSource_ptr _ptr_type;
00253 typedef ImageRepRgbSource_var _var_type;
00254
00255 static inline ImageRepRgbSource_ptr
00256 _duplicate(ImageRepRgbSource_ptr p)
00257 {
00258 if(p)
00259 p -> _add_ref();
00260 return p;
00261 }
00262
00263 static inline ImageRepRgbSource_ptr
00264 _nil()
00265 {
00266 return 0;
00267 }
00268
00269 static ImageRepRgbSource_ptr _narrow(CORBA::Object_ptr);
00270 static ImageRepRgbSource_ptr _unchecked_narrow(CORBA::Object_ptr);
00271
00272 static ImageRepRgbSource_ptr _narrow(CORBA::AbstractBase_ptr);
00273 static ImageRepRgbSource_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00274
00275 static const char** _OB_staticIds();
00276
00277
00278
00279
00280 virtual void setDisplayMode(const char* displayMode) = 0;
00281
00282
00283
00284
00285 virtual char* getDisplayMode() = 0;
00286
00287
00288
00289
00290 virtual void setSize(const Sizes& newSize) = 0;
00291
00292
00293
00294
00295 virtual void setMaxSize(const Sizes& maxSize) = 0;
00296
00297
00298
00299
00300 virtual void scale(CORBA::Float factor) = 0;
00301
00302
00303
00304
00305 virtual void setTransferSize(CORBA::Long nLines) = 0;
00306
00307
00308
00309
00310 virtual CORBA::Long getTransferSize() = 0;
00311
00312
00313
00314
00315 virtual void setTransferPos(CORBA::Long line) = 0;
00316
00317
00318
00319
00320 virtual CORBA::Long getTransferPos() = 0;
00321
00322
00323
00324
00325 virtual Sizes getSizes() = 0;
00326
00327
00328
00329
00330 virtual Sizes getOriginalSizes() = 0;
00331
00332
00333
00334
00335 virtual void close() = 0;
00336 };
00337
00338
00339
00340
00341 class ImageData : virtual public CORBA::Object
00342 {
00343 ImageData(const ImageData&);
00344 void operator=(const ImageData&);
00345
00346 protected:
00347
00348 static const char* ids_[];
00349
00350 public:
00351
00352 ImageData() { }
00353 virtual ~ImageData() { }
00354
00355 typedef ImageData_ptr _ptr_type;
00356 typedef ImageData_var _var_type;
00357
00358 static inline ImageData_ptr
00359 _duplicate(ImageData_ptr p)
00360 {
00361 if(p)
00362 p -> _add_ref();
00363 return p;
00364 }
00365
00366 static inline ImageData_ptr
00367 _nil()
00368 {
00369 return 0;
00370 }
00371
00372 static ImageData_ptr _narrow(CORBA::Object_ptr);
00373 static ImageData_ptr _unchecked_narrow(CORBA::Object_ptr);
00374
00375 static ImageData_ptr _narrow(CORBA::AbstractBase_ptr);
00376 static ImageData_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00377
00378 static const char** _OB_staticIds();
00379
00380
00381
00382
00383 virtual CORBA::Long dimensionality() = 0;
00384
00385
00386
00387
00388 virtual CORBA::Long numberOfPixels() = 0;
00389
00390
00391
00392
00393 virtual CORBA::Long pixelDimensionality() = 0;
00394
00395
00396
00397
00398 virtual CORBA::Long pixelPrecision() = 0;
00399
00400
00401
00402
00403 virtual PixelT pixelType() = 0;
00404
00405
00406
00407
00408 virtual Sizes getSizes() = 0;
00409
00410
00411
00412
00413 virtual CORBA::Long dimensionSize(CORBA::Long i) = 0;
00414
00415
00416
00417
00418 virtual ImageSignature signature() = 0;
00419
00420
00421
00422
00423 virtual RgbSeq* getRgb2d(const char* displayMode) = 0;
00424
00425
00426
00427
00428 virtual void fillRgb2d(RgbBuffer_ptr buf,
00429 const char* displayMode) = 0;
00430
00431
00432
00433
00434 virtual ImageRepRgbSource_ptr getRgbSource() = 0;
00435 };
00436
00437
00438
00439
00440 enum GeoIntType
00441 {
00442 LINEAR,
00443 NEAREST
00444 };
00445
00446 typedef GeoIntType& GeoIntType_out;
00447
00448 extern OB::TypeCodeConst _tc_GeoIntType;
00449
00450
00451
00452
00453 enum GeoTransType
00454 {
00455 FORWARD,
00456 BACKWARD
00457 };
00458
00459 typedef GeoTransType& GeoTransType_out;
00460
00461 extern OB::TypeCodeConst _tc_GeoTransType;
00462
00463
00464
00465
00466 enum ResultPrecision
00467 {
00468 SOURCE_PREC,
00469 ARITH_PREC,
00470 SMALL_PREC
00471 };
00472
00473 typedef ResultPrecision& ResultPrecision_out;
00474
00475 extern OB::TypeCodeConst _tc_ResultPrecision;
00476
00477
00478
00479
00480 struct ImageException : public CORBA::UserException
00481 {
00482 ImageException() { }
00483 ImageException(const ImageException&);
00484 ImageException& operator=(const ImageException&);
00485
00486 static ImageException* _downcast(CORBA::Exception*);
00487 static const ImageException* _downcast(const CORBA::Exception*);
00488 virtual const char* _name() const;
00489 virtual void _raise() const { throw *this; }
00490 virtual const char* _rep_id() const;
00491 virtual char* _to_string() const;
00492
00493 virtual CORBA::Exception* _OB_clone() const;
00494 virtual void _OB_insertInAny(CORBA::Any&);
00495
00496 OB::StrForStruct message;
00497
00498 ImageException(const char*);
00499
00500 virtual void _OB_marshal(OB::OutputStreamImpl*) const;
00501 static void _OB_unmarshal(ImageException&, OB::InputStreamImpl*);
00502 };
00503
00504 extern OB::TypeCodeConst _tc_ImageException;
00505
00506
00507
00508
00509 class OBUnique_ImageList { };
00510
00511 typedef OB::ObjSeq< ImageRep, OBUnique_ImageList > ImageList;
00512 typedef OB::SeqVar< OB::ObjSeq< ImageRep, OBUnique_ImageList > > ImageList_var;
00513 typedef OB::SeqOut< OB::ObjSeq< ImageRep, OBUnique_ImageList > > ImageList_out;
00514 extern OB::TypeCodeConst _tc_ImageList;
00515
00516 struct OBInfo_ImageList : public OB::ConstructedInfo
00517 {
00518 OBInfo_ImageList() { }
00519
00520 virtual void free(void* p) const
00521 {
00522 delete (ImageList*)p;
00523 }
00524
00525 virtual void* dup(const void* p) const
00526 {
00527 return new ImageList(*(const ImageList*)p);
00528 }
00529
00530 virtual void marshal(const void*, OB::OutputStreamImpl*) const;
00531 virtual void unmarshal(void*, OB::InputStreamImpl*) const;
00532 };
00533
00534
00535
00536
00537 class ImageRep : virtual public ::HxCorba::ImageData,
00538 virtual public ::HxCorba::RefCountBase
00539 {
00540 ImageRep(const ImageRep&);
00541 void operator=(const ImageRep&);
00542
00543 protected:
00544
00545 static const char* ids_[];
00546
00547 public:
00548
00549 ImageRep() { }
00550 virtual ~ImageRep() { }
00551
00552 typedef ImageRep_ptr _ptr_type;
00553 typedef ImageRep_var _var_type;
00554
00555 static inline ImageRep_ptr
00556 _duplicate(ImageRep_ptr p)
00557 {
00558 if(p)
00559 p -> _add_ref();
00560 return p;
00561 }
00562
00563 static inline ImageRep_ptr
00564 _nil()
00565 {
00566 return 0;
00567 }
00568
00569 static ImageRep_ptr _narrow(CORBA::Object_ptr);
00570 static ImageRep_ptr _unchecked_narrow(CORBA::Object_ptr);
00571
00572 static ImageRep_ptr _narrow(CORBA::AbstractBase_ptr);
00573 static ImageRep_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00574
00575 static const char** _OB_staticIds();
00576
00577
00578
00579
00580 virtual ImageRep_ptr binaryPixOp(ImageRep_ptr arg,
00581 const char* bpoName,
00582 TagList_ptr tags) = 0;
00583
00584
00585
00586
00587 virtual ImageRep_ptr binaryPixOpVal(const PixValue& arg,
00588 const char* bpoName,
00589 TagList_ptr tags) = 0;
00590
00591
00592
00593
00594 virtual ImageRep_ptr unaryPixOp(const char* upoName,
00595 TagList_ptr tags) = 0;
00596
00597
00598
00599
00600 virtual ImageRep_ptr multiPixOp(const ImageList& args,
00601 const char* mpoName,
00602 TagList_ptr tags) = 0;
00603
00604
00605
00606
00607 virtual ImageList* MNPixOp(const ImageList& args,
00608 const char* mpoName,
00609 TagList_ptr tags) = 0;
00610
00611
00612
00613
00614 virtual PixValue reduceOp(const char* op,
00615 TagList_ptr tags) = 0;
00616
00617
00618
00619
00620 virtual ImageRep_ptr generalizedConvolution(ImageRep_ptr kernel,
00621 const char* gMul,
00622 const char* gAdd,
00623 ResultPrecision resPrec,
00624 TagList_ptr tags) = 0;
00625
00626
00627
00628
00629 virtual ImageRep_ptr genConv2dSep(ImageRep_ptr kernel1,
00630 ImageRep_ptr kernel2,
00631 const char* gMul,
00632 const char* gAdd,
00633 ResultPrecision resPrec,
00634 TagList_ptr tags) = 0;
00635
00636
00637
00638
00639 virtual ImageRep_ptr recGenConv(ImageRep_ptr kerImg,
00640 const char* gMul,
00641 const char* gAdd,
00642 ResultPrecision resPrec,
00643 TagList_ptr tags) = 0;
00644
00645
00646
00647
00648 virtual ImageRep_ptr neighbourhoodOp(const char* ngbName,
00649 TagList_ptr tags) = 0;
00650
00651
00652
00653
00654 virtual ImageRep_ptr geometricOp2d(Matrix_ptr func,
00655 GeoIntType gi,
00656 GeoTransType gt,
00657 CORBA::Boolean adjustSize,
00658 const PixValue& background) = 0;
00659
00660
00661
00662
00663 virtual ImageRep_ptr scale(CORBA::Double sx,
00664 CORBA::Double sy,
00665 GeoIntType gi) = 0;
00666
00667
00668
00669
00670 virtual PixValue getAt(CORBA::Long x,
00671 CORBA::Long y,
00672 CORBA::Long zz) = 0;
00673
00674
00675
00676
00677 virtual void destroy() = 0;
00678 };
00679
00680
00681
00682
00683 class ImageFactory : virtual public CORBA::Object
00684 {
00685 ImageFactory(const ImageFactory&);
00686 void operator=(const ImageFactory&);
00687
00688 protected:
00689
00690 static const char* ids_[];
00691
00692 public:
00693
00694 ImageFactory() { }
00695 virtual ~ImageFactory() { }
00696
00697 typedef ImageFactory_ptr _ptr_type;
00698 typedef ImageFactory_var _var_type;
00699
00700 static inline ImageFactory_ptr
00701 _duplicate(ImageFactory_ptr p)
00702 {
00703 if(p)
00704 p -> _add_ref();
00705 return p;
00706 }
00707
00708 static inline ImageFactory_ptr
00709 _nil()
00710 {
00711 return 0;
00712 }
00713
00714 static ImageFactory_ptr _narrow(CORBA::Object_ptr);
00715 static ImageFactory_ptr _unchecked_narrow(CORBA::Object_ptr);
00716
00717 static ImageFactory_ptr _narrow(CORBA::AbstractBase_ptr);
00718 static ImageFactory_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00719
00720 static const char** _OB_staticIds();
00721
00722
00723
00724
00725 virtual ImageRep_ptr importImage(ImageData_ptr data) = 0;
00726
00727
00728
00729
00730 virtual ImageRep_ptr fromSignature(ImageSignature sig,
00731 const Sizes& size) = 0;
00732
00733
00734
00735
00736 virtual ImageRep_ptr fromImage(ImageSignature sig,
00737 ImageRep_ptr src) = 0;
00738
00739
00740
00741
00742 virtual ImageRep_ptr fromValue(ImageSignature sig,
00743 const Sizes& size,
00744 const PixValue& val) = 0;
00745
00746
00747
00748
00749 virtual ImageRep_ptr fromByteData(CORBA::Long pixelDimensionality,
00750 CORBA::Long dimensions,
00751 const Sizes& size,
00752 const OctetSeq& data) = 0;
00753
00754
00755
00756
00757 virtual ImageRep_ptr fromShortData(CORBA::Long pixelDimensionality,
00758 CORBA::Long dimensions,
00759 const Sizes& size,
00760 const ShortSeq& data) = 0;
00761
00762
00763
00764
00765 virtual ImageRep_ptr fromIntData(CORBA::Long pixelDimensionality,
00766 CORBA::Long dimensions,
00767 const Sizes& size,
00768 const LongSeq& data) = 0;
00769
00770
00771
00772
00773 virtual ImageRep_ptr fromFloatData(CORBA::Long pixelDimensionality,
00774 CORBA::Long dimensions,
00775 const Sizes& size,
00776 const FloatSeq& data) = 0;
00777
00778
00779
00780
00781 virtual ImageRep_ptr fromDoubleData(CORBA::Long pixelDimensionality,
00782 CORBA::Long dimensions,
00783 const Sizes& size,
00784 const DoubleSeq& data) = 0;
00785
00786
00787
00788
00789 virtual ImageRep_ptr fromJavaRgb(ImageSignature sig,
00790 const Sizes& size,
00791 const RgbSeq& pixels) = 0;
00792
00793
00794
00795
00796 virtual ImageRep_ptr fromGrayValue(ImageSignature sig,
00797 const Sizes& size,
00798 const OctetSeq& pixels) = 0;
00799
00800
00801
00802
00803 virtual ImageRep_ptr fromMatlab(ImageSignature sig,
00804 const Sizes& size,
00805 const DoubleSeq& pixels) = 0;
00806
00807
00808
00809
00810 virtual ImageRep_ptr fromNamedGenerator(ImageSignature sig,
00811 const char* generatorName,
00812 TagList_ptr tags) = 0;
00813
00814
00815
00816
00817 virtual ImageRep_ptr fromImport(ImageSignature sig,
00818 const Sizes& size,
00819 const char* importOp,
00820 TagList_ptr tags) = 0;
00821
00822
00823
00824
00825 virtual ImageRep_ptr from2Images(ImageRep_ptr i1,
00826 ImageRep_ptr i2) = 0;
00827
00828
00829
00830
00831 virtual ImageRep_ptr from3Images(ImageRep_ptr i1,
00832 ImageRep_ptr i2,
00833 ImageRep_ptr i3) = 0;
00834
00835
00836
00837
00838 virtual ImageRep_ptr fromFile(const char* fileName) = 0;
00839 };
00840
00841 }
00842
00843
00844
00845
00846 namespace OBProxy_HxCorba
00847 {
00848
00849
00850
00851
00852 class ImageRepRgbSource : virtual public ::HxCorba::ImageRepRgbSource,
00853 virtual public OBProxy_HxCorba::RgbSource
00854 {
00855 ImageRepRgbSource(const ImageRepRgbSource&);
00856 void operator=(const ImageRepRgbSource&);
00857
00858 protected:
00859
00860 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00861
00862 public:
00863
00864 ImageRepRgbSource() { }
00865 virtual ~ImageRepRgbSource() { }
00866
00867 virtual const char** _OB_ids() const;
00868
00869
00870
00871
00872 void setDisplayMode(const char* displayMode);
00873
00874
00875
00876
00877 char* getDisplayMode();
00878
00879
00880
00881
00882 void setSize(const ::HxCorba::Sizes& newSize);
00883
00884
00885
00886
00887 void setMaxSize(const ::HxCorba::Sizes& maxSize);
00888
00889
00890
00891
00892 void scale(CORBA::Float factor);
00893
00894
00895
00896
00897 void setTransferSize(CORBA::Long nLines);
00898
00899
00900
00901
00902 CORBA::Long getTransferSize();
00903
00904
00905
00906
00907 void setTransferPos(CORBA::Long line);
00908
00909
00910
00911
00912 CORBA::Long getTransferPos();
00913
00914
00915
00916
00917 ::HxCorba::Sizes getSizes();
00918
00919
00920
00921
00922 ::HxCorba::Sizes getOriginalSizes();
00923
00924
00925
00926
00927 void close();
00928 };
00929
00930
00931
00932
00933 class ImageData : virtual public ::HxCorba::ImageData,
00934 virtual public OBCORBA::Object
00935 {
00936 ImageData(const ImageData&);
00937 void operator=(const ImageData&);
00938
00939 protected:
00940
00941 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00942
00943 public:
00944
00945 ImageData() { }
00946 virtual ~ImageData() { }
00947
00948 virtual const char** _OB_ids() const;
00949
00950
00951
00952
00953 CORBA::Long dimensionality();
00954
00955
00956
00957
00958 CORBA::Long numberOfPixels();
00959
00960
00961
00962
00963 CORBA::Long pixelDimensionality();
00964
00965
00966
00967
00968 CORBA::Long pixelPrecision();
00969
00970
00971
00972
00973 ::HxCorba::PixelT pixelType();
00974
00975
00976
00977
00978 ::HxCorba::Sizes getSizes();
00979
00980
00981
00982
00983 CORBA::Long dimensionSize(CORBA::Long i);
00984
00985
00986
00987
00988 ::HxCorba::ImageSignature signature();
00989
00990
00991
00992
00993 ::HxCorba::RgbSeq* getRgb2d(const char* displayMode);
00994
00995
00996
00997
00998 void fillRgb2d(::HxCorba::RgbBuffer_ptr buf,
00999 const char* displayMode);
01000
01001
01002
01003
01004 ::HxCorba::ImageRepRgbSource_ptr getRgbSource();
01005 };
01006
01007
01008
01009
01010 class ImageRep : virtual public ::HxCorba::ImageRep,
01011 virtual public OBProxy_HxCorba::ImageData,
01012 virtual public OBProxy_HxCorba::RefCountBase
01013 {
01014 ImageRep(const ImageRep&);
01015 void operator=(const ImageRep&);
01016
01017 protected:
01018
01019 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01020
01021 public:
01022
01023 ImageRep() { }
01024 virtual ~ImageRep() { }
01025
01026 virtual const char** _OB_ids() const;
01027
01028
01029
01030
01031 ::HxCorba::ImageRep_ptr binaryPixOp(::HxCorba::ImageRep_ptr arg,
01032 const char* bpoName,
01033 ::HxCorba::TagList_ptr tags);
01034
01035
01036
01037
01038 ::HxCorba::ImageRep_ptr binaryPixOpVal(const ::HxCorba::PixValue& arg,
01039 const char* bpoName,
01040 ::HxCorba::TagList_ptr tags);
01041
01042
01043
01044
01045 ::HxCorba::ImageRep_ptr unaryPixOp(const char* upoName,
01046 ::HxCorba::TagList_ptr tags);
01047
01048
01049
01050
01051 ::HxCorba::ImageRep_ptr multiPixOp(const ::HxCorba::ImageList& args,
01052 const char* mpoName,
01053 ::HxCorba::TagList_ptr tags);
01054
01055
01056
01057
01058 ::HxCorba::ImageList* MNPixOp(const ::HxCorba::ImageList& args,
01059 const char* mpoName,
01060 ::HxCorba::TagList_ptr tags);
01061
01062
01063
01064
01065 ::HxCorba::PixValue reduceOp(const char* op,
01066 ::HxCorba::TagList_ptr tags);
01067
01068
01069
01070
01071 ::HxCorba::ImageRep_ptr generalizedConvolution(::HxCorba::ImageRep_ptr kernel,
01072 const char* gMul,
01073 const char* gAdd,
01074 ::HxCorba::ResultPrecision resPrec,
01075 ::HxCorba::TagList_ptr tags);
01076
01077
01078
01079
01080 ::HxCorba::ImageRep_ptr genConv2dSep(::HxCorba::ImageRep_ptr kernel1,
01081 ::HxCorba::ImageRep_ptr kernel2,
01082 const char* gMul,
01083 const char* gAdd,
01084 ::HxCorba::ResultPrecision resPrec,
01085 ::HxCorba::TagList_ptr tags);
01086
01087
01088
01089
01090 ::HxCorba::ImageRep_ptr recGenConv(::HxCorba::ImageRep_ptr kerImg,
01091 const char* gMul,
01092 const char* gAdd,
01093 ::HxCorba::ResultPrecision resPrec,
01094 ::HxCorba::TagList_ptr tags);
01095
01096
01097
01098
01099 ::HxCorba::ImageRep_ptr neighbourhoodOp(const char* ngbName,
01100 ::HxCorba::TagList_ptr tags);
01101
01102
01103
01104
01105 ::HxCorba::ImageRep_ptr geometricOp2d(::HxCorba::Matrix_ptr func,
01106 ::HxCorba::GeoIntType gi,
01107 ::HxCorba::GeoTransType gt,
01108 CORBA::Boolean adjustSize,
01109 const ::HxCorba::PixValue& background);
01110
01111
01112
01113
01114 ::HxCorba::ImageRep_ptr scale(CORBA::Double sx,
01115 CORBA::Double sy,
01116 ::HxCorba::GeoIntType gi);
01117
01118
01119
01120
01121 ::HxCorba::PixValue getAt(CORBA::Long x,
01122 CORBA::Long y,
01123 CORBA::Long zz);
01124
01125
01126
01127
01128 void destroy();
01129 };
01130
01131
01132
01133
01134 class ImageFactory : virtual public ::HxCorba::ImageFactory,
01135 virtual public OBCORBA::Object
01136 {
01137 ImageFactory(const ImageFactory&);
01138 void operator=(const ImageFactory&);
01139
01140 protected:
01141
01142 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
01143
01144 public:
01145
01146 ImageFactory() { }
01147 virtual ~ImageFactory() { }
01148
01149 virtual const char** _OB_ids() const;
01150
01151
01152
01153
01154 ::HxCorba::ImageRep_ptr importImage(::HxCorba::ImageData_ptr data);
01155
01156
01157
01158
01159 ::HxCorba::ImageRep_ptr fromSignature(::HxCorba::ImageSignature sig,
01160 const ::HxCorba::Sizes& size);
01161
01162
01163
01164
01165 ::HxCorba::ImageRep_ptr fromImage(::HxCorba::ImageSignature sig,
01166 ::HxCorba::ImageRep_ptr src);
01167
01168
01169
01170
01171 ::HxCorba::ImageRep_ptr fromValue(::HxCorba::ImageSignature sig,
01172 const ::HxCorba::Sizes& size,
01173 const ::HxCorba::PixValue& val);
01174
01175
01176
01177
01178 ::HxCorba::ImageRep_ptr fromByteData(CORBA::Long pixelDimensionality,
01179 CORBA::Long dimensions,
01180 const ::HxCorba::Sizes& size,
01181 const ::HxCorba::OctetSeq& data);
01182
01183
01184
01185
01186 ::HxCorba::ImageRep_ptr fromShortData(CORBA::Long pixelDimensionality,
01187 CORBA::Long dimensions,
01188 const ::HxCorba::Sizes& size,
01189 const ::HxCorba::ShortSeq& data);
01190
01191
01192
01193
01194 ::HxCorba::ImageRep_ptr fromIntData(CORBA::Long pixelDimensionality,
01195 CORBA::Long dimensions,
01196 const ::HxCorba::Sizes& size,
01197 const ::HxCorba::LongSeq& data);
01198
01199
01200
01201
01202 ::HxCorba::ImageRep_ptr fromFloatData(CORBA::Long pixelDimensionality,
01203 CORBA::Long dimensions,
01204 const ::HxCorba::Sizes& size,
01205 const ::HxCorba::FloatSeq& data);
01206
01207
01208
01209
01210 ::HxCorba::ImageRep_ptr fromDoubleData(CORBA::Long pixelDimensionality,
01211 CORBA::Long dimensions,
01212 const ::HxCorba::Sizes& size,
01213 const ::HxCorba::DoubleSeq& data);
01214
01215
01216
01217
01218 ::HxCorba::ImageRep_ptr fromJavaRgb(::HxCorba::ImageSignature sig,
01219 const ::HxCorba::Sizes& size,
01220 const ::HxCorba::RgbSeq& pixels);
01221
01222
01223
01224
01225 ::HxCorba::ImageRep_ptr fromGrayValue(::HxCorba::ImageSignature sig,
01226 const ::HxCorba::Sizes& size,
01227 const ::HxCorba::OctetSeq& pixels);
01228
01229
01230
01231
01232 ::HxCorba::ImageRep_ptr fromMatlab(::HxCorba::ImageSignature sig,
01233 const ::HxCorba::Sizes& size,
01234 const ::HxCorba::DoubleSeq& pixels);
01235
01236
01237
01238
01239 ::HxCorba::ImageRep_ptr fromNamedGenerator(::HxCorba::ImageSignature sig,
01240 const char* generatorName,
01241 ::HxCorba::TagList_ptr tags);
01242
01243
01244
01245
01246 ::HxCorba::ImageRep_ptr fromImport(::HxCorba::ImageSignature sig,
01247 const ::HxCorba::Sizes& size,
01248 const char* importOp,
01249 ::HxCorba::TagList_ptr tags);
01250
01251
01252
01253
01254 ::HxCorba::ImageRep_ptr from2Images(::HxCorba::ImageRep_ptr i1,
01255 ::HxCorba::ImageRep_ptr i2);
01256
01257
01258
01259
01260 ::HxCorba::ImageRep_ptr from3Images(::HxCorba::ImageRep_ptr i1,
01261 ::HxCorba::ImageRep_ptr i2,
01262 ::HxCorba::ImageRep_ptr i3);
01263
01264
01265
01266
01267 ::HxCorba::ImageRep_ptr fromFile(const char* fileName);
01268 };
01269
01270 }
01271
01272
01273
01274
01275 namespace OBStubImpl_HxCorba
01276 {
01277
01278
01279
01280
01281 class ImageRepRgbSource : virtual public OBStubImpl_HxCorba::RgbSource
01282 {
01283 ImageRepRgbSource(const ImageRepRgbSource&);
01284 void operator=(const ImageRepRgbSource&);
01285
01286 protected:
01287
01288 ImageRepRgbSource() { }
01289
01290 public:
01291
01292 static inline ImageRepRgbSource_ptr
01293 _duplicate(ImageRepRgbSource_ptr p)
01294 {
01295 if(p)
01296 p -> _OB_incRef();
01297 return p;
01298 }
01299
01300 static inline ImageRepRgbSource_ptr
01301 _nil()
01302 {
01303 return 0;
01304 }
01305
01306
01307
01308
01309 virtual void setDisplayMode(const char* displayMode) = 0;
01310
01311
01312
01313
01314 virtual char* getDisplayMode() = 0;
01315
01316
01317
01318
01319 virtual void setSize(const ::HxCorba::Sizes& newSize) = 0;
01320
01321
01322
01323
01324 virtual void setMaxSize(const ::HxCorba::Sizes& maxSize) = 0;
01325
01326
01327
01328
01329 virtual void scale(CORBA::Float factor) = 0;
01330
01331
01332
01333
01334 virtual void setTransferSize(CORBA::Long nLines) = 0;
01335
01336
01337
01338
01339 virtual CORBA::Long getTransferSize() = 0;
01340
01341
01342
01343
01344 virtual void setTransferPos(CORBA::Long line) = 0;
01345
01346
01347
01348
01349 virtual CORBA::Long getTransferPos() = 0;
01350
01351
01352
01353
01354 virtual ::HxCorba::Sizes getSizes() = 0;
01355
01356
01357
01358
01359 virtual ::HxCorba::Sizes getOriginalSizes() = 0;
01360
01361
01362
01363
01364 virtual void close() = 0;
01365 };
01366
01367
01368
01369
01370 class ImageData : virtual public OB::StubImplBase
01371 {
01372 ImageData(const ImageData&);
01373 void operator=(const ImageData&);
01374
01375 protected:
01376
01377 ImageData() { }
01378
01379 public:
01380
01381 static inline ImageData_ptr
01382 _duplicate(ImageData_ptr p)
01383 {
01384 if(p)
01385 p -> _OB_incRef();
01386 return p;
01387 }
01388
01389 static inline ImageData_ptr
01390 _nil()
01391 {
01392 return 0;
01393 }
01394
01395
01396
01397
01398 virtual CORBA::Long dimensionality() = 0;
01399
01400
01401
01402
01403 virtual CORBA::Long numberOfPixels() = 0;
01404
01405
01406
01407
01408 virtual CORBA::Long pixelDimensionality() = 0;
01409
01410
01411
01412
01413 virtual CORBA::Long pixelPrecision() = 0;
01414
01415
01416
01417
01418 virtual ::HxCorba::PixelT pixelType() = 0;
01419
01420
01421
01422
01423 virtual ::HxCorba::Sizes getSizes() = 0;
01424
01425
01426
01427
01428 virtual CORBA::Long dimensionSize(CORBA::Long i) = 0;
01429
01430
01431
01432
01433 virtual ::HxCorba::ImageSignature signature() = 0;
01434
01435
01436
01437
01438 virtual ::HxCorba::RgbSeq* getRgb2d(const char* displayMode) = 0;
01439
01440
01441
01442
01443 virtual void fillRgb2d(::HxCorba::RgbBuffer_ptr buf,
01444 const char* displayMode) = 0;
01445
01446
01447
01448
01449 virtual ::HxCorba::ImageRepRgbSource_ptr getRgbSource() = 0;
01450 };
01451
01452
01453
01454
01455 class ImageRep : virtual public OBStubImpl_HxCorba::ImageData,
01456 virtual public OBStubImpl_HxCorba::RefCountBase
01457 {
01458 ImageRep(const ImageRep&);
01459 void operator=(const ImageRep&);
01460
01461 protected:
01462
01463 ImageRep() { }
01464
01465 public:
01466
01467 static inline ImageRep_ptr
01468 _duplicate(ImageRep_ptr p)
01469 {
01470 if(p)
01471 p -> _OB_incRef();
01472 return p;
01473 }
01474
01475 static inline ImageRep_ptr
01476 _nil()
01477 {
01478 return 0;
01479 }
01480
01481
01482
01483
01484 virtual ::HxCorba::ImageRep_ptr binaryPixOp(::HxCorba::ImageRep_ptr arg,
01485 const char* bpoName,
01486 ::HxCorba::TagList_ptr tags) = 0;
01487
01488
01489
01490
01491 virtual ::HxCorba::ImageRep_ptr binaryPixOpVal(const ::HxCorba::PixValue& arg,
01492 const char* bpoName,
01493 ::HxCorba::TagList_ptr tags) = 0;
01494
01495
01496
01497
01498 virtual ::HxCorba::ImageRep_ptr unaryPixOp(const char* upoName,
01499 ::HxCorba::TagList_ptr tags) = 0;
01500
01501
01502
01503
01504 virtual ::HxCorba::ImageRep_ptr multiPixOp(const ::HxCorba::ImageList& args,
01505 const char* mpoName,
01506 ::HxCorba::TagList_ptr tags) = 0;
01507
01508
01509
01510
01511 virtual ::HxCorba::ImageList* MNPixOp(const ::HxCorba::ImageList& args,
01512 const char* mpoName,
01513 ::HxCorba::TagList_ptr tags) = 0;
01514
01515
01516
01517
01518 virtual ::HxCorba::PixValue reduceOp(const char* op,
01519 ::HxCorba::TagList_ptr tags) = 0;
01520
01521
01522
01523
01524 virtual ::HxCorba::ImageRep_ptr generalizedConvolution(::HxCorba::ImageRep_ptr kernel,
01525 const char* gMul,
01526 const char* gAdd,
01527 ::HxCorba::ResultPrecision resPrec,
01528 ::HxCorba::TagList_ptr tags) = 0;
01529
01530
01531
01532
01533 virtual ::HxCorba::ImageRep_ptr genConv2dSep(::HxCorba::ImageRep_ptr kernel1,
01534 ::HxCorba::ImageRep_ptr kernel2,
01535 const char* gMul,
01536 const char* gAdd,
01537 ::HxCorba::ResultPrecision resPrec,
01538 ::HxCorba::TagList_ptr tags) = 0;
01539
01540
01541
01542
01543 virtual ::HxCorba::ImageRep_ptr recGenConv(::HxCorba::ImageRep_ptr kerImg,
01544 const char* gMul,
01545 const char* gAdd,
01546 ::HxCorba::ResultPrecision resPrec,
01547 ::HxCorba::TagList_ptr tags) = 0;
01548
01549
01550
01551
01552 virtual ::HxCorba::ImageRep_ptr neighbourhoodOp(const char* ngbName,
01553 ::HxCorba::TagList_ptr tags) = 0;
01554
01555
01556
01557
01558 virtual ::HxCorba::ImageRep_ptr geometricOp2d(::HxCorba::Matrix_ptr func,
01559 ::HxCorba::GeoIntType gi,
01560 ::HxCorba::GeoTransType gt,
01561 CORBA::Boolean adjustSize,
01562 const ::HxCorba::PixValue& background) = 0;
01563
01564
01565
01566
01567 virtual ::HxCorba::ImageRep_ptr scale(CORBA::Double sx,
01568 CORBA::Double sy,
01569 ::HxCorba::GeoIntType gi) = 0;
01570
01571
01572
01573
01574 virtual ::HxCorba::PixValue getAt(CORBA::Long x,
01575 CORBA::Long y,
01576 CORBA::Long zz) = 0;
01577
01578
01579
01580
01581 virtual void destroy() = 0;
01582 };
01583
01584
01585
01586
01587 class ImageFactory : virtual public OB::StubImplBase
01588 {
01589 ImageFactory(const ImageFactory&);
01590 void operator=(const ImageFactory&);
01591
01592 protected:
01593
01594 ImageFactory() { }
01595
01596 public:
01597
01598 static inline ImageFactory_ptr
01599 _duplicate(ImageFactory_ptr p)
01600 {
01601 if(p)
01602 p -> _OB_incRef();
01603 return p;
01604 }
01605
01606 static inline ImageFactory_ptr
01607 _nil()
01608 {
01609 return 0;
01610 }
01611
01612
01613
01614
01615 virtual ::HxCorba::ImageRep_ptr importImage(::HxCorba::ImageData_ptr data) = 0;
01616
01617
01618
01619
01620 virtual ::HxCorba::ImageRep_ptr fromSignature(::HxCorba::ImageSignature sig,
01621 const ::HxCorba::Sizes& size) = 0;
01622
01623
01624
01625
01626 virtual ::HxCorba::ImageRep_ptr fromImage(::HxCorba::ImageSignature sig,
01627 ::HxCorba::ImageRep_ptr src) = 0;
01628
01629
01630
01631
01632 virtual ::HxCorba::ImageRep_ptr fromValue(::HxCorba::ImageSignature sig,
01633 const ::HxCorba::Sizes& size,
01634 const ::HxCorba::PixValue& val) = 0;
01635
01636
01637
01638
01639 virtual ::HxCorba::ImageRep_ptr fromByteData(CORBA::Long pixelDimensionality,
01640 CORBA::Long dimensions,
01641 const ::HxCorba::Sizes& size,
01642 const ::HxCorba::OctetSeq& data) = 0;
01643
01644
01645
01646
01647 virtual ::HxCorba::ImageRep_ptr fromShortData(CORBA::Long pixelDimensionality,
01648 CORBA::Long dimensions,
01649 const ::HxCorba::Sizes& size,
01650 const ::HxCorba::ShortSeq& data) = 0;
01651
01652
01653
01654
01655 virtual ::HxCorba::ImageRep_ptr fromIntData(CORBA::Long pixelDimensionality,
01656 CORBA::Long dimensions,
01657 const ::HxCorba::Sizes& size,
01658 const ::HxCorba::LongSeq& data) = 0;
01659
01660
01661
01662
01663 virtual ::HxCorba::ImageRep_ptr fromFloatData(CORBA::Long pixelDimensionality,
01664 CORBA::Long dimensions,
01665 const ::HxCorba::Sizes& size,
01666 const ::HxCorba::FloatSeq& data) = 0;
01667
01668
01669
01670
01671 virtual ::HxCorba::ImageRep_ptr fromDoubleData(CORBA::Long pixelDimensionality,
01672 CORBA::Long dimensions,
01673 const ::HxCorba::Sizes& size,
01674 const ::HxCorba::DoubleSeq& data) = 0;
01675
01676
01677
01678
01679 virtual ::HxCorba::ImageRep_ptr fromJavaRgb(::HxCorba::ImageSignature sig,
01680 const ::HxCorba::Sizes& size,
01681 const ::HxCorba::RgbSeq& pixels) = 0;
01682
01683
01684
01685
01686 virtual ::HxCorba::ImageRep_ptr fromGrayValue(::HxCorba::ImageSignature sig,
01687 const ::HxCorba::Sizes& size,
01688 const ::HxCorba::OctetSeq& pixels) = 0;
01689
01690
01691
01692
01693 virtual ::HxCorba::ImageRep_ptr fromMatlab(::HxCorba::ImageSignature sig,
01694 const ::HxCorba::Sizes& size,
01695 const ::HxCorba::DoubleSeq& pixels) = 0;
01696
01697
01698
01699
01700 virtual ::HxCorba::ImageRep_ptr fromNamedGenerator(::HxCorba::ImageSignature sig,
01701 const char* generatorName,
01702 ::HxCorba::TagList_ptr tags) = 0;
01703
01704
01705
01706
01707 virtual ::HxCorba::ImageRep_ptr fromImport(::HxCorba::ImageSignature sig,
01708 const ::HxCorba::Sizes& size,
01709 const char* importOp,
01710 ::HxCorba::TagList_ptr tags) = 0;
01711
01712
01713
01714
01715 virtual ::HxCorba::ImageRep_ptr from2Images(::HxCorba::ImageRep_ptr i1,
01716 ::HxCorba::ImageRep_ptr i2) = 0;
01717
01718
01719
01720
01721 virtual ::HxCorba::ImageRep_ptr from3Images(::HxCorba::ImageRep_ptr i1,
01722 ::HxCorba::ImageRep_ptr i2,
01723 ::HxCorba::ImageRep_ptr i3) = 0;
01724
01725
01726
01727
01728 virtual ::HxCorba::ImageRep_ptr fromFile(const char* fileName) = 0;
01729 };
01730
01731 }
01732
01733
01734
01735
01736 namespace OBMarshalStubImpl_HxCorba
01737 {
01738
01739
01740
01741
01742 class ImageRepRgbSource : virtual public OBStubImpl_HxCorba::ImageRepRgbSource,
01743 virtual public OBMarshalStubImpl_HxCorba::RgbSource
01744 {
01745 ImageRepRgbSource(const ImageRepRgbSource&);
01746 void operator=(const ImageRepRgbSource&);
01747
01748 protected:
01749
01750 ImageRepRgbSource() { }
01751 friend class OBProxy_HxCorba::ImageRepRgbSource;
01752
01753 public:
01754
01755
01756
01757
01758 virtual void setDisplayMode(const char* displayMode);
01759
01760
01761
01762
01763 virtual char* getDisplayMode();
01764
01765
01766
01767
01768 virtual void setSize(const ::HxCorba::Sizes& newSize);
01769
01770
01771
01772
01773 virtual void setMaxSize(const ::HxCorba::Sizes& maxSize);
01774
01775
01776
01777
01778 virtual void scale(CORBA::Float factor);
01779
01780
01781
01782
01783 virtual void setTransferSize(CORBA::Long nLines);
01784
01785
01786
01787
01788 virtual CORBA::Long getTransferSize();
01789
01790
01791
01792
01793 virtual void setTransferPos(CORBA::Long line);
01794
01795
01796
01797
01798 virtual CORBA::Long getTransferPos();
01799
01800
01801
01802
01803 virtual ::HxCorba::Sizes getSizes();
01804
01805
01806
01807
01808 virtual ::HxCorba::Sizes getOriginalSizes();
01809
01810
01811
01812
01813 virtual void close();
01814 };
01815
01816
01817
01818
01819 class ImageData : virtual public OBStubImpl_HxCorba::ImageData,
01820 virtual public OB::MarshalStubImpl
01821 {
01822 ImageData(const ImageData&);
01823 void operator=(const ImageData&);
01824
01825 protected:
01826
01827 ImageData() { }
01828 friend class OBProxy_HxCorba::ImageData;
01829
01830 public:
01831
01832
01833
01834
01835 virtual CORBA::Long dimensionality();
01836
01837
01838
01839
01840 virtual CORBA::Long numberOfPixels();
01841
01842
01843
01844
01845 virtual CORBA::Long pixelDimensionality();
01846
01847
01848
01849
01850 virtual CORBA::Long pixelPrecision();
01851
01852
01853
01854
01855 virtual ::HxCorba::PixelT pixelType();
01856
01857
01858
01859
01860 virtual ::HxCorba::Sizes getSizes();
01861
01862
01863
01864
01865 virtual CORBA::Long dimensionSize(CORBA::Long i);
01866
01867
01868
01869
01870 virtual ::HxCorba::ImageSignature signature();
01871
01872
01873
01874
01875 virtual ::HxCorba::RgbSeq* getRgb2d(const char* displayMode);
01876
01877
01878
01879
01880 virtual void fillRgb2d(::HxCorba::RgbBuffer_ptr buf,
01881 const char* displayMode);
01882
01883
01884
01885
01886 virtual ::HxCorba::ImageRepRgbSource_ptr getRgbSource();
01887 };
01888
01889
01890
01891
01892 class ImageRep : virtual public OBStubImpl_HxCorba::ImageRep,
01893 virtual public OBMarshalStubImpl_HxCorba::ImageData,
01894 virtual public OBMarshalStubImpl_HxCorba::RefCountBase
01895 {
01896 ImageRep(const ImageRep&);
01897 void operator=(const ImageRep&);
01898
01899 protected:
01900
01901 ImageRep() { }
01902 friend class OBProxy_HxCorba::ImageRep;
01903
01904 public:
01905
01906
01907
01908
01909 virtual ::HxCorba::ImageRep_ptr binaryPixOp(::HxCorba::ImageRep_ptr arg,
01910 const char* bpoName,
01911 ::HxCorba::TagList_ptr tags);
01912
01913
01914
01915
01916 virtual ::HxCorba::ImageRep_ptr binaryPixOpVal(const ::HxCorba::PixValue& arg,
01917 const char* bpoName,
01918 ::HxCorba::TagList_ptr tags);
01919
01920
01921
01922
01923 virtual ::HxCorba::ImageRep_ptr unaryPixOp(const char* upoName,
01924 ::HxCorba::TagList_ptr tags);
01925
01926
01927
01928
01929 virtual ::HxCorba::ImageRep_ptr multiPixOp(const ::HxCorba::ImageList& args,
01930 const char* mpoName,
01931 ::HxCorba::TagList_ptr tags);
01932
01933
01934
01935
01936 virtual ::HxCorba::ImageList* MNPixOp(const ::HxCorba::ImageList& args,
01937 const char* mpoName,
01938 ::HxCorba::TagList_ptr tags);
01939
01940
01941
01942
01943 virtual ::HxCorba::PixValue reduceOp(const char* op,
01944 ::HxCorba::TagList_ptr tags);
01945
01946
01947
01948
01949 virtual ::HxCorba::ImageRep_ptr generalizedConvolution(::HxCorba::ImageRep_ptr kernel,
01950 const char* gMul,
01951 const char* gAdd,
01952 ::HxCorba::ResultPrecision resPrec,
01953 ::HxCorba::TagList_ptr tags);
01954
01955
01956
01957
01958 virtual ::HxCorba::ImageRep_ptr genConv2dSep(::HxCorba::ImageRep_ptr kernel1,
01959 ::HxCorba::ImageRep_ptr kernel2,
01960 const char* gMul,
01961 const char* gAdd,
01962 ::HxCorba::ResultPrecision resPrec,
01963 ::HxCorba::TagList_ptr tags);
01964
01965
01966
01967
01968 virtual ::HxCorba::ImageRep_ptr recGenConv(::HxCorba::ImageRep_ptr kerImg,
01969 const char* gMul,
01970 const char* gAdd,
01971 ::HxCorba::ResultPrecision resPrec,
01972 ::HxCorba::TagList_ptr tags);
01973
01974
01975
01976
01977 virtual ::HxCorba::ImageRep_ptr neighbourhoodOp(const char* ngbName,
01978 ::HxCorba::TagList_ptr tags);
01979
01980
01981
01982
01983 virtual ::HxCorba::ImageRep_ptr geometricOp2d(::HxCorba::Matrix_ptr func,
01984 ::HxCorba::GeoIntType gi,
01985 ::HxCorba::GeoTransType gt,
01986 CORBA::Boolean adjustSize,
01987 const ::HxCorba::PixValue& background);
01988
01989
01990
01991
01992 virtual ::HxCorba::ImageRep_ptr scale(CORBA::Double sx,
01993 CORBA::Double sy,
01994 ::HxCorba::GeoIntType gi);
01995
01996
01997
01998
01999 virtual ::HxCorba::PixValue getAt(CORBA::Long x,
02000 CORBA::Long y,
02001 CORBA::Long zz);
02002
02003
02004
02005
02006 virtual void destroy();
02007 };
02008
02009
02010
02011
02012 class ImageFactory : virtual public OBStubImpl_HxCorba::ImageFactory,
02013 virtual public OB::MarshalStubImpl
02014 {
02015 ImageFactory(const ImageFactory&);
02016 void operator=(const ImageFactory&);
02017
02018 protected:
02019
02020 ImageFactory() { }
02021 friend class OBProxy_HxCorba::ImageFactory;
02022
02023 public:
02024
02025
02026
02027
02028 virtual ::HxCorba::ImageRep_ptr importImage(::HxCorba::ImageData_ptr data);
02029
02030
02031
02032
02033 virtual ::HxCorba::ImageRep_ptr fromSignature(::HxCorba::ImageSignature sig,
02034 const ::HxCorba::Sizes& size);
02035
02036
02037
02038
02039 virtual ::HxCorba::ImageRep_ptr fromImage(::HxCorba::ImageSignature sig,
02040 ::HxCorba::ImageRep_ptr src);
02041
02042
02043
02044
02045 virtual ::HxCorba::ImageRep_ptr fromValue(::HxCorba::ImageSignature sig,
02046 const ::HxCorba::Sizes& size,
02047 const ::HxCorba::PixValue& val);
02048
02049
02050
02051
02052 virtual ::HxCorba::ImageRep_ptr fromByteData(CORBA::Long pixelDimensionality,
02053 CORBA::Long dimensions,
02054 const ::HxCorba::Sizes& size,
02055 const ::HxCorba::OctetSeq& data);
02056
02057
02058
02059
02060 virtual ::HxCorba::ImageRep_ptr fromShortData(CORBA::Long pixelDimensionality,
02061 CORBA::Long dimensions,
02062 const ::HxCorba::Sizes& size,
02063 const ::HxCorba::ShortSeq& data);
02064
02065
02066
02067
02068 virtual ::HxCorba::ImageRep_ptr fromIntData(CORBA::Long pixelDimensionality,
02069 CORBA::Long dimensions,
02070 const ::HxCorba::Sizes& size,
02071 const ::HxCorba::LongSeq& data);
02072
02073
02074
02075
02076 virtual ::HxCorba::ImageRep_ptr fromFloatData(CORBA::Long pixelDimensionality,
02077 CORBA::Long dimensions,
02078 const ::HxCorba::Sizes& size,
02079 const ::HxCorba::FloatSeq& data);
02080
02081
02082
02083
02084 virtual ::HxCorba::ImageRep_ptr fromDoubleData(CORBA::Long pixelDimensionality,
02085 CORBA::Long dimensions,
02086 const ::HxCorba::Sizes& size,
02087 const ::HxCorba::DoubleSeq& data);
02088
02089
02090
02091
02092 virtual ::HxCorba::ImageRep_ptr fromJavaRgb(::HxCorba::ImageSignature sig,
02093 const ::HxCorba::Sizes& size,
02094 const ::HxCorba::RgbSeq& pixels);
02095
02096
02097
02098
02099 virtual ::HxCorba::ImageRep_ptr fromGrayValue(::HxCorba::ImageSignature sig,
02100 const ::HxCorba::Sizes& size,
02101 const ::HxCorba::OctetSeq& pixels);
02102
02103
02104
02105
02106 virtual ::HxCorba::ImageRep_ptr fromMatlab(::HxCorba::ImageSignature sig,
02107 const ::HxCorba::Sizes& size,
02108 const ::HxCorba::DoubleSeq& pixels);
02109
02110
02111
02112
02113 virtual ::HxCorba::ImageRep_ptr fromNamedGenerator(::HxCorba::ImageSignature sig,
02114 const char* generatorName,
02115 ::HxCorba::TagList_ptr tags);
02116
02117
02118
02119
02120 virtual ::HxCorba::ImageRep_ptr fromImport(::HxCorba::ImageSignature sig,
02121 const ::HxCorba::Sizes& size,
02122 const char* importOp,
02123 ::HxCorba::TagList_ptr tags);
02124
02125
02126
02127
02128 virtual ::HxCorba::ImageRep_ptr from2Images(::HxCorba::ImageRep_ptr i1,
02129 ::HxCorba::ImageRep_ptr i2);
02130
02131
02132
02133
02134 virtual ::HxCorba::ImageRep_ptr from3Images(::HxCorba::ImageRep_ptr i1,
02135 ::HxCorba::ImageRep_ptr i2,
02136 ::HxCorba::ImageRep_ptr i3);
02137
02138
02139
02140
02141 virtual ::HxCorba::ImageRep_ptr fromFile(const char* fileName);
02142 };
02143
02144 }
02145
02146
02147
02148
02149 namespace OBV_HxCorba
02150 {
02151
02152 }
02153
02154
02155
02156
02157 void operator<<=(CORBA::Any&, HxCorba::PixelT);
02158 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::PixelT&);
02159
02160 inline void
02161 operator<<=(CORBA::Any_var& any, HxCorba::PixelT val)
02162 {
02163 any.inout() <<= val;
02164 }
02165
02166 inline CORBA::Boolean
02167 operator>>=(const CORBA::Any_var& any, HxCorba::PixelT& val)
02168 {
02169 return any.in() >>= val;
02170 }
02171
02172
02173
02174
02175 void operator<<=(CORBA::Any&, HxCorba::ImageSignature);
02176 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageSignature&);
02177
02178 inline void
02179 operator<<=(CORBA::Any_var& any, HxCorba::ImageSignature val)
02180 {
02181 any.inout() <<= val;
02182 }
02183
02184 inline CORBA::Boolean
02185 operator>>=(const CORBA::Any_var& any, HxCorba::ImageSignature& val)
02186 {
02187 return any.in() >>= val;
02188 }
02189
02190
02191
02192
02193 void operator<<=(CORBA::Any&, HxCorba::Sizes*);
02194 void operator<<=(CORBA::Any&, const HxCorba::Sizes&);
02195 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::Sizes*&);
02196
02197 inline void
02198 operator<<=(CORBA::Any_var& any, HxCorba::Sizes* val)
02199 {
02200 any.inout() <<= val;
02201 }
02202
02203 inline void
02204 operator<<=(CORBA::Any_var& any, const HxCorba::Sizes& val)
02205 {
02206 any.inout() <<= val;
02207 }
02208
02209 inline CORBA::Boolean
02210 operator>>=(const CORBA::Any_var& any, const HxCorba::Sizes*& val)
02211 {
02212 return any.in() >>= val;
02213 }
02214
02215
02216
02217
02218 void operator<<=(CORBA::Any&, HxCorba::Point*);
02219 void operator<<=(CORBA::Any&, const HxCorba::Point&);
02220 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::Point*&);
02221
02222 inline void
02223 operator<<=(CORBA::Any_var& any, HxCorba::Point* val)
02224 {
02225 any.inout() <<= val;
02226 }
02227
02228 inline void
02229 operator<<=(CORBA::Any_var& any, const HxCorba::Point& val)
02230 {
02231 any.inout() <<= val;
02232 }
02233
02234 inline CORBA::Boolean
02235 operator>>=(const CORBA::Any_var& any, const HxCorba::Point*& val)
02236 {
02237 return any.in() >>= val;
02238 }
02239
02240
02241
02242
02243 namespace CORBA
02244 {
02245
02246 inline void
02247 release(::HxCorba::ImageRepRgbSource_ptr p)
02248 {
02249 if(p)
02250 p -> _remove_ref();
02251 }
02252
02253 inline Boolean
02254 is_nil(::HxCorba::ImageRepRgbSource_ptr p)
02255 {
02256 return p == 0;
02257 }
02258
02259 inline void
02260 release(OBStubImpl_HxCorba::ImageRepRgbSource_ptr p)
02261 {
02262 if(p)
02263 p -> _OB_decRef();
02264 }
02265
02266 inline Boolean
02267 is_nil(OBStubImpl_HxCorba::ImageRepRgbSource_ptr p)
02268 {
02269 return p == 0;
02270 }
02271
02272 }
02273
02274 void operator<<=(CORBA::Any&, HxCorba::ImageRepRgbSource_ptr*);
02275 void operator<<=(CORBA::Any&, HxCorba::ImageRepRgbSource_ptr);
02276 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageRepRgbSource_ptr&);
02277
02278 inline void
02279 operator<<=(CORBA::Any_var& any, HxCorba::ImageRepRgbSource_ptr* val)
02280 {
02281 any.inout() <<= val;
02282 }
02283
02284 inline void
02285 operator<<=(CORBA::Any_var& any, HxCorba::ImageRepRgbSource_ptr val)
02286 {
02287 any.inout() <<= val;
02288 }
02289
02290 inline CORBA::Boolean
02291 operator>>=(const CORBA::Any_var& any, HxCorba::ImageRepRgbSource_ptr& val)
02292 {
02293 return any.in() >>= val;
02294 }
02295
02296
02297
02298
02299 namespace CORBA
02300 {
02301
02302 inline void
02303 release(::HxCorba::ImageData_ptr p)
02304 {
02305 if(p)
02306 p -> _remove_ref();
02307 }
02308
02309 inline Boolean
02310 is_nil(::HxCorba::ImageData_ptr p)
02311 {
02312 return p == 0;
02313 }
02314
02315 inline void
02316 release(OBStubImpl_HxCorba::ImageData_ptr p)
02317 {
02318 if(p)
02319 p -> _OB_decRef();
02320 }
02321
02322 inline Boolean
02323 is_nil(OBStubImpl_HxCorba::ImageData_ptr p)
02324 {
02325 return p == 0;
02326 }
02327
02328 }
02329
02330 void operator<<=(CORBA::Any&, HxCorba::ImageData_ptr*);
02331 void operator<<=(CORBA::Any&, HxCorba::ImageData_ptr);
02332 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageData_ptr&);
02333
02334 inline void
02335 operator<<=(CORBA::Any_var& any, HxCorba::ImageData_ptr* val)
02336 {
02337 any.inout() <<= val;
02338 }
02339
02340 inline void
02341 operator<<=(CORBA::Any_var& any, HxCorba::ImageData_ptr val)
02342 {
02343 any.inout() <<= val;
02344 }
02345
02346 inline CORBA::Boolean
02347 operator>>=(const CORBA::Any_var& any, HxCorba::ImageData_ptr& val)
02348 {
02349 return any.in() >>= val;
02350 }
02351
02352
02353
02354
02355 void operator<<=(CORBA::Any&, HxCorba::GeoIntType);
02356 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::GeoIntType&);
02357
02358 inline void
02359 operator<<=(CORBA::Any_var& any, HxCorba::GeoIntType val)
02360 {
02361 any.inout() <<= val;
02362 }
02363
02364 inline CORBA::Boolean
02365 operator>>=(const CORBA::Any_var& any, HxCorba::GeoIntType& val)
02366 {
02367 return any.in() >>= val;
02368 }
02369
02370
02371
02372
02373 void operator<<=(CORBA::Any&, HxCorba::GeoTransType);
02374 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::GeoTransType&);
02375
02376 inline void
02377 operator<<=(CORBA::Any_var& any, HxCorba::GeoTransType val)
02378 {
02379 any.inout() <<= val;
02380 }
02381
02382 inline CORBA::Boolean
02383 operator>>=(const CORBA::Any_var& any, HxCorba::GeoTransType& val)
02384 {
02385 return any.in() >>= val;
02386 }
02387
02388
02389
02390
02391 void operator<<=(CORBA::Any&, HxCorba::ResultPrecision);
02392 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ResultPrecision&);
02393
02394 inline void
02395 operator<<=(CORBA::Any_var& any, HxCorba::ResultPrecision val)
02396 {
02397 any.inout() <<= val;
02398 }
02399
02400 inline CORBA::Boolean
02401 operator>>=(const CORBA::Any_var& any, HxCorba::ResultPrecision& val)
02402 {
02403 return any.in() >>= val;
02404 }
02405
02406
02407
02408
02409 void operator<<=(CORBA::Any&, HxCorba::ImageException*);
02410 void operator<<=(CORBA::Any&, const HxCorba::ImageException&);
02411 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::ImageException*&);
02412
02413 inline void
02414 operator<<=(CORBA::Any_var& any, HxCorba::ImageException* val)
02415 {
02416 any.inout() <<= val;
02417 }
02418
02419 inline void
02420 operator<<=(CORBA::Any_var& any, const HxCorba::ImageException& val)
02421 {
02422 any.inout() <<= val;
02423 }
02424
02425 inline CORBA::Boolean
02426 operator>>=(const CORBA::Any_var& any, const HxCorba::ImageException*& val)
02427 {
02428 return any.in() >>= val;
02429 }
02430
02431
02432
02433
02434 void operator<<=(CORBA::Any&, HxCorba::ImageList*);
02435 void operator<<=(CORBA::Any&, const HxCorba::ImageList&);
02436 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::ImageList*&);
02437
02438 inline void
02439 operator<<=(CORBA::Any_var& any, HxCorba::ImageList* val)
02440 {
02441 any.inout() <<= val;
02442 }
02443
02444 inline void
02445 operator<<=(CORBA::Any_var& any, const HxCorba::ImageList& val)
02446 {
02447 any.inout() <<= val;
02448 }
02449
02450 inline CORBA::Boolean
02451 operator>>=(const CORBA::Any_var& any, const HxCorba::ImageList*& val)
02452 {
02453 return any.in() >>= val;
02454 }
02455
02456
02457
02458
02459 namespace CORBA
02460 {
02461
02462 inline void
02463 release(::HxCorba::ImageRep_ptr p)
02464 {
02465 if(p)
02466 p -> _remove_ref();
02467 }
02468
02469 inline Boolean
02470 is_nil(::HxCorba::ImageRep_ptr p)
02471 {
02472 return p == 0;
02473 }
02474
02475 inline void
02476 release(OBStubImpl_HxCorba::ImageRep_ptr p)
02477 {
02478 if(p)
02479 p -> _OB_decRef();
02480 }
02481
02482 inline Boolean
02483 is_nil(OBStubImpl_HxCorba::ImageRep_ptr p)
02484 {
02485 return p == 0;
02486 }
02487
02488 }
02489
02490 void operator<<=(CORBA::Any&, HxCorba::ImageRep_ptr*);
02491 void operator<<=(CORBA::Any&, HxCorba::ImageRep_ptr);
02492 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageRep_ptr&);
02493
02494 inline void
02495 operator<<=(CORBA::Any_var& any, HxCorba::ImageRep_ptr* val)
02496 {
02497 any.inout() <<= val;
02498 }
02499
02500 inline void
02501 operator<<=(CORBA::Any_var& any, HxCorba::ImageRep_ptr val)
02502 {
02503 any.inout() <<= val;
02504 }
02505
02506 inline CORBA::Boolean
02507 operator>>=(const CORBA::Any_var& any, HxCorba::ImageRep_ptr& val)
02508 {
02509 return any.in() >>= val;
02510 }
02511
02512
02513
02514
02515 namespace CORBA
02516 {
02517
02518 inline void
02519 release(::HxCorba::ImageFactory_ptr p)
02520 {
02521 if(p)
02522 p -> _remove_ref();
02523 }
02524
02525 inline Boolean
02526 is_nil(::HxCorba::ImageFactory_ptr p)
02527 {
02528 return p == 0;
02529 }
02530
02531 inline void
02532 release(OBStubImpl_HxCorba::ImageFactory_ptr p)
02533 {
02534 if(p)
02535 p -> _OB_decRef();
02536 }
02537
02538 inline Boolean
02539 is_nil(OBStubImpl_HxCorba::ImageFactory_ptr p)
02540 {
02541 return p == 0;
02542 }
02543
02544 }
02545
02546 void operator<<=(CORBA::Any&, HxCorba::ImageFactory_ptr*);
02547 void operator<<=(CORBA::Any&, HxCorba::ImageFactory_ptr);
02548 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageFactory_ptr&);
02549
02550 inline void
02551 operator<<=(CORBA::Any_var& any, HxCorba::ImageFactory_ptr* val)
02552 {
02553 any.inout() <<= val;
02554 }
02555
02556 inline void
02557 operator<<=(CORBA::Any_var& any, HxCorba::ImageFactory_ptr val)
02558 {
02559 any.inout() <<= val;
02560 }
02561
02562 inline CORBA::Boolean
02563 operator>>=(const CORBA::Any_var& any, HxCorba::ImageFactory_ptr& val)
02564 {
02565 return any.in() >>= val;
02566 }
02567
02568 #endif