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 != 4000500L)
00030 # error ORBacus version mismatch!
00031 # endif
00032 #endif
00033
00034 namespace HxCorba
00035 {
00036
00037 class ImageData;
00038 typedef ImageData* ImageData_ptr;
00039 typedef ImageData* ImageDataRef;
00040
00041 extern OB::TypeCodeConst _tc_ImageData;
00042
00043 class ImageRep;
00044 typedef ImageRep* ImageRep_ptr;
00045 typedef ImageRep* ImageRepRef;
00046
00047 extern OB::TypeCodeConst _tc_ImageRep;
00048
00049 class ImageFactory;
00050 typedef ImageFactory* ImageFactory_ptr;
00051 typedef ImageFactory* ImageFactoryRef;
00052
00053 extern OB::TypeCodeConst _tc_ImageFactory;
00054
00055 }
00056
00057 void OBDuplicate(HxCorba::ImageData_ptr);
00058 void OBRelease(HxCorba::ImageData_ptr);
00059
00060 void OBMarshal(HxCorba::ImageData_ptr, OB::OutputStreamImpl*);
00061 void OBUnmarshal(HxCorba::ImageData_ptr&, OB::InputStreamImpl*);
00062
00063 void OBDuplicate(HxCorba::ImageRep_ptr);
00064 void OBRelease(HxCorba::ImageRep_ptr);
00065
00066 void OBMarshal(HxCorba::ImageRep_ptr, OB::OutputStreamImpl*);
00067 void OBUnmarshal(HxCorba::ImageRep_ptr&, OB::InputStreamImpl*);
00068
00069 void OBDuplicate(HxCorba::ImageFactory_ptr);
00070 void OBRelease(HxCorba::ImageFactory_ptr);
00071
00072 void OBMarshal(HxCorba::ImageFactory_ptr, OB::OutputStreamImpl*);
00073 void OBUnmarshal(HxCorba::ImageFactory_ptr&, OB::InputStreamImpl*);
00074
00075 namespace HxCorba
00076 {
00077
00078 typedef OB::ObjVar< ImageData > ImageData_var;
00079 typedef OB::ObjOut< ImageData > ImageData_out;
00080
00081 typedef OB::ObjVar< ImageRep > ImageRep_var;
00082 typedef OB::ObjOut< ImageRep > ImageRep_out;
00083
00084 typedef OB::ObjVar< ImageFactory > ImageFactory_var;
00085 typedef OB::ObjOut< ImageFactory > ImageFactory_out;
00086
00087 }
00088
00089 namespace OBStubImpl_HxCorba
00090 {
00091
00092 class ImageData;
00093 typedef ImageData* ImageData_ptr;
00094
00095 class ImageRep;
00096 typedef ImageRep* ImageRep_ptr;
00097
00098 class ImageFactory;
00099 typedef ImageFactory* ImageFactory_ptr;
00100
00101 }
00102
00103 void OBDuplicate(OBStubImpl_HxCorba::ImageData_ptr);
00104 void OBRelease(OBStubImpl_HxCorba::ImageData_ptr);
00105
00106 void OBDuplicate(OBStubImpl_HxCorba::ImageRep_ptr);
00107 void OBRelease(OBStubImpl_HxCorba::ImageRep_ptr);
00108
00109 void OBDuplicate(OBStubImpl_HxCorba::ImageFactory_ptr);
00110 void OBRelease(OBStubImpl_HxCorba::ImageFactory_ptr);
00111
00112 namespace OBStubImpl_HxCorba
00113 {
00114
00115 typedef OB::ObjVar< ImageData > ImageData_var;
00116
00117 typedef OB::ObjVar< ImageRep > ImageRep_var;
00118
00119 typedef OB::ObjVar< ImageFactory > ImageFactory_var;
00120
00121 }
00122
00123
00124
00125
00126 namespace HxCorba
00127 {
00128
00129
00130
00131
00132 enum PixelT
00133 {
00134 INT_VALUE,
00135 REAL_VALUE,
00136 COMPLEX_VALUE
00137 };
00138
00139 typedef PixelT& PixelT_out;
00140
00141 extern OB::TypeCodeConst _tc_PixelT;
00142
00143
00144
00145
00146 enum ImageSignature
00147 {
00148 SIG2DBYTE,
00149 SIG2DSHORT,
00150 SIG2DINT,
00151 SIG2DFLOAT,
00152 SIG2DDOUBLE,
00153 SIG2DVEC2BYTE,
00154 SIG2DVEC2SHORT,
00155 SIG2DVEC2INT,
00156 SIG2DVEC2FLOAT,
00157 SIG2DVEC2DOUBLE,
00158 SIG2DVEC3BYTE,
00159 SIG2DVEC3SHORT,
00160 SIG2DVEC3INT,
00161 SIG2DVEC3FLOAT,
00162 SIG2DVEC3DOUBLE,
00163 SIG2DCOMPLEX
00164 };
00165
00166 typedef ImageSignature& ImageSignature_out;
00167
00168 extern OB::TypeCodeConst _tc_ImageSignature;
00169
00170
00171
00172
00173 struct Sizes;
00174 typedef OB::FixVar< Sizes > Sizes_var;
00175 typedef Sizes& Sizes_out;
00176
00177 struct Sizes
00178 {
00179 typedef Sizes_var _var_type;
00180
00181 CORBA::Long x;
00182 CORBA::Long y;
00183 CORBA::Long z;
00184
00185 void _OB_marshal(OB::OutputStreamImpl*) const;
00186 static void _OB_unmarshal(Sizes&, OB::InputStreamImpl*);
00187 };
00188
00189 extern OB::TypeCodeConst _tc_Sizes;
00190
00191
00192
00193
00194 struct Point;
00195 typedef OB::FixVar< Point > Point_var;
00196 typedef Point& Point_out;
00197
00198 struct Point
00199 {
00200 typedef Point_var _var_type;
00201
00202 CORBA::Double x;
00203 CORBA::Double y;
00204 CORBA::Double z;
00205
00206 void _OB_marshal(OB::OutputStreamImpl*) const;
00207 static void _OB_unmarshal(Point&, OB::InputStreamImpl*);
00208 };
00209
00210 extern OB::TypeCodeConst _tc_Point;
00211
00212
00213
00214
00215 class ImageData : virtual public CORBA::Object
00216 {
00217 ImageData(const ImageData&);
00218 void operator=(const ImageData&);
00219
00220 static const char* ids_[];
00221
00222 protected:
00223
00224 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00225
00226 public:
00227
00228 ImageData() { }
00229 virtual ~ImageData() { }
00230
00231 typedef ImageData_ptr _ptr_type;
00232 typedef ImageData_var _var_type;
00233
00234 static inline ImageData_ptr
00235 _duplicate(ImageData_ptr p)
00236 {
00237 if(p)
00238 p -> _OB_incRef();
00239 return p;
00240 }
00241
00242 static inline ImageData_ptr
00243 _nil()
00244 {
00245 return 0;
00246 }
00247
00248 static ImageData_ptr _narrow(CORBA::Object_ptr);
00249 static ImageData_ptr _narrow(CORBA::AbstractBase_ptr);
00250
00251 virtual const char** _OB_ids() const;
00252 static const char** _OB_staticIds();
00253
00254
00255
00256
00257 CORBA::Long dimensionality();
00258
00259
00260
00261
00262 CORBA::Long numberOfPixels();
00263
00264
00265
00266
00267 CORBA::Long pixelDimensionality();
00268
00269
00270
00271
00272 CORBA::Long pixelPrecision();
00273
00274
00275
00276
00277 PixelT pixelType();
00278
00279
00280
00281
00282 Sizes getSizes();
00283
00284
00285
00286
00287 CORBA::Long dimensionSize(CORBA::Long i);
00288
00289
00290
00291
00292 ImageSignature signature();
00293
00294
00295
00296
00297 RgbSeq* getRgb2d(const char* displayMode);
00298
00299
00300
00301
00302 void fillRgb2d(RgbBuffer_ptr buf,
00303 const char* displayMode);
00304 };
00305
00306
00307
00308
00309 enum GeoIntType
00310 {
00311 LINEAR,
00312 NEAREST
00313 };
00314
00315 typedef GeoIntType& GeoIntType_out;
00316
00317 extern OB::TypeCodeConst _tc_GeoIntType;
00318
00319
00320
00321
00322 enum GeoTransType
00323 {
00324 FORWARD,
00325 BACKWARD
00326 };
00327
00328 typedef GeoTransType& GeoTransType_out;
00329
00330 extern OB::TypeCodeConst _tc_GeoTransType;
00331
00332
00333
00334
00335 enum ResultPrecision
00336 {
00337 SOURCE_PREC,
00338 ARITH_PREC,
00339 SMALL_PREC
00340 };
00341
00342 typedef ResultPrecision& ResultPrecision_out;
00343
00344 extern OB::TypeCodeConst _tc_ResultPrecision;
00345
00346
00347
00348
00349 struct ImageException : public CORBA::UserException
00350 {
00351 ImageException() { }
00352 ImageException(const ImageException&);
00353 ImageException& operator=(const ImageException&);
00354
00355 static ImageException* _downcast(CORBA::Exception*);
00356 static const ImageException* _downcast(const CORBA::Exception*);
00357 virtual const char* _name() const;
00358 virtual void _raise() const { throw *this; }
00359 virtual const char* _rep_id() const;
00360 virtual char* _to_string() const;
00361
00362 virtual CORBA::Exception* _OB_clone() const;
00363 virtual void _OB_insertInAny(CORBA::Any&);
00364
00365 OB::StrForStruct message;
00366
00367 ImageException(const char*);
00368
00369 virtual void _OB_marshal(OB::OutputStreamImpl*) const;
00370 static void _OB_unmarshal(ImageException&, OB::InputStreamImpl*);
00371 };
00372
00373 extern OB::TypeCodeConst _tc_ImageException;
00374
00375
00376
00377
00378 class OBUnique_ImageList { };
00379
00380 typedef OB::ObjSeq< ImageRep, OBUnique_ImageList > ImageList;
00381 typedef OB::SeqVar< OB::ObjSeq< ImageRep, OBUnique_ImageList > > ImageList_var;
00382 typedef OB::SeqOut< OB::ObjSeq< ImageRep, OBUnique_ImageList > > ImageList_out;
00383 extern OB::TypeCodeConst _tc_ImageList;
00384
00385 struct OBInfo_ImageList : public OB::ConstructedInfo
00386 {
00387 OBInfo_ImageList() { }
00388
00389 virtual void free(void* p) const
00390 {
00391 delete (ImageList*)p;
00392 }
00393
00394 virtual void* dup(const void* p) const
00395 {
00396 return new ImageList(*(const ImageList*)p);
00397 }
00398
00399 virtual void marshal(const void*, OB::OutputStreamImpl*) const;
00400 virtual void unmarshal(void*, OB::InputStreamImpl*) const;
00401 };
00402
00403
00404
00405
00406 class ImageRep : virtual public HxCorba::ImageData,
00407 virtual public HxCorba::RefCountBase
00408 {
00409 ImageRep(const ImageRep&);
00410 void operator=(const ImageRep&);
00411
00412 static const char* ids_[];
00413
00414 protected:
00415
00416 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00417
00418 public:
00419
00420 ImageRep() { }
00421 virtual ~ImageRep() { }
00422
00423 typedef ImageRep_ptr _ptr_type;
00424 typedef ImageRep_var _var_type;
00425
00426 static inline ImageRep_ptr
00427 _duplicate(ImageRep_ptr p)
00428 {
00429 if(p)
00430 p -> _OB_incRef();
00431 return p;
00432 }
00433
00434 static inline ImageRep_ptr
00435 _nil()
00436 {
00437 return 0;
00438 }
00439
00440 static ImageRep_ptr _narrow(CORBA::Object_ptr);
00441 static ImageRep_ptr _narrow(CORBA::AbstractBase_ptr);
00442
00443 virtual const char** _OB_ids() const;
00444 static const char** _OB_staticIds();
00445
00446
00447
00448
00449 ImageRep_ptr binaryPixOp(ImageRep_ptr arg,
00450 const char* bpoName,
00451 TagList_ptr tags);
00452
00453
00454
00455
00456 ImageRep_ptr binaryPixOpVal(const PixValue& arg,
00457 const char* bpoName,
00458 TagList_ptr tags);
00459
00460
00461
00462
00463 ImageRep_ptr unaryPixOp(const char* upoName,
00464 TagList_ptr tags);
00465
00466
00467
00468
00469 ImageRep_ptr multiPixOp(const ImageList& args,
00470 const char* mpoName,
00471 TagList_ptr tags);
00472
00473
00474
00475
00476 ImageList* MNPixOp(const ImageList& args,
00477 const char* mpoName,
00478 TagList_ptr tags);
00479
00480
00481
00482
00483 PixValue reduceOp(const char* op,
00484 TagList_ptr tags);
00485
00486
00487
00488
00489 ImageRep_ptr generalizedConvolution(ImageRep_ptr kernel,
00490 const char* gMul,
00491 const char* gAdd,
00492 ResultPrecision resPrec,
00493 TagList_ptr tags);
00494
00495
00496
00497
00498 ImageRep_ptr generalizedConvolutionK1d(CORBA::Long dimension,
00499 ImageRep_ptr kernel,
00500 const char* gMul,
00501 const char* gAdd,
00502 ResultPrecision resPrec,
00503 TagList_ptr tags);
00504
00505
00506
00507
00508 ImageRep_ptr neighbourhoodOp(const char* ngbName,
00509 TagList_ptr tags);
00510
00511
00512
00513
00514 ImageRep_ptr recursiveNeighOp(ImageRep_ptr kerImg,
00515 const char* gMul,
00516 const char* gAdd,
00517 TagList_ptr tags,
00518 ResultPrecision resPrec);
00519
00520
00521
00522
00523 ImageRep_ptr geometricOp2d(Matrix_ptr func,
00524 GeoIntType gi,
00525 GeoTransType gt,
00526 CORBA::Boolean adjustSize,
00527 const PixValue& background);
00528
00529
00530
00531
00532 ImageRep_ptr scale(CORBA::Double sx,
00533 CORBA::Double sy,
00534 GeoIntType gi);
00535
00536
00537
00538
00539 PixValue getAt(CORBA::Long x,
00540 CORBA::Long y,
00541 CORBA::Long zz);
00542 };
00543
00544
00545
00546
00547 class ImageFactory : virtual public CORBA::Object
00548 {
00549 ImageFactory(const ImageFactory&);
00550 void operator=(const ImageFactory&);
00551
00552 static const char* ids_[];
00553
00554 protected:
00555
00556 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00557
00558 public:
00559
00560 ImageFactory() { }
00561 virtual ~ImageFactory() { }
00562
00563 typedef ImageFactory_ptr _ptr_type;
00564 typedef ImageFactory_var _var_type;
00565
00566 static inline ImageFactory_ptr
00567 _duplicate(ImageFactory_ptr p)
00568 {
00569 if(p)
00570 p -> _OB_incRef();
00571 return p;
00572 }
00573
00574 static inline ImageFactory_ptr
00575 _nil()
00576 {
00577 return 0;
00578 }
00579
00580 static ImageFactory_ptr _narrow(CORBA::Object_ptr);
00581 static ImageFactory_ptr _narrow(CORBA::AbstractBase_ptr);
00582
00583 virtual const char** _OB_ids() const;
00584 static const char** _OB_staticIds();
00585
00586
00587
00588
00589 ImageRep_ptr importImage(ImageData_ptr data);
00590
00591
00592
00593
00594 ImageRep_ptr fromSignature(ImageSignature sig,
00595 const Sizes& size);
00596
00597
00598
00599
00600 ImageRep_ptr fromImage(ImageSignature sig,
00601 ImageRep_ptr src);
00602
00603
00604
00605
00606 ImageRep_ptr fromValue(ImageSignature sig,
00607 const Sizes& size,
00608 const PixValue& val);
00609
00610
00611
00612
00613 ImageRep_ptr fromByteData(CORBA::Long pixelDimensionality,
00614 CORBA::Long dimensions,
00615 const Sizes& size,
00616 const OctetSeq& data);
00617
00618
00619
00620
00621 ImageRep_ptr fromShortData(CORBA::Long pixelDimensionality,
00622 CORBA::Long dimensions,
00623 const Sizes& size,
00624 const ShortSeq& data);
00625
00626
00627
00628
00629 ImageRep_ptr fromIntData(CORBA::Long pixelDimensionality,
00630 CORBA::Long dimensions,
00631 const Sizes& size,
00632 const LongSeq& data);
00633
00634
00635
00636
00637 ImageRep_ptr fromFloatData(CORBA::Long pixelDimensionality,
00638 CORBA::Long dimensions,
00639 const Sizes& size,
00640 const FloatSeq& data);
00641
00642
00643
00644
00645 ImageRep_ptr fromDoubleData(CORBA::Long pixelDimensionality,
00646 CORBA::Long dimensions,
00647 const Sizes& size,
00648 const DoubleSeq& data);
00649
00650
00651
00652
00653 ImageRep_ptr fromJavaRgb(ImageSignature sig,
00654 const Sizes& size,
00655 const RgbSeq& pixels);
00656
00657
00658
00659
00660 ImageRep_ptr fromGrayValue(ImageSignature sig,
00661 const Sizes& size,
00662 const OctetSeq& pixels);
00663
00664
00665
00666
00667 ImageRep_ptr fromMatlab(ImageSignature sig,
00668 const Sizes& size,
00669 const DoubleSeq& pixels);
00670
00671
00672
00673
00674 ImageRep_ptr fromNamedGenerator(ImageSignature sig,
00675 const char* generatorName,
00676 TagList_ptr tags);
00677
00678
00679
00680
00681 ImageRep_ptr fromImport(ImageSignature sig,
00682 const Sizes& size,
00683 const char* importOp,
00684 TagList_ptr tags);
00685
00686
00687
00688
00689 ImageRep_ptr from2Images(ImageRep_ptr i1,
00690 ImageRep_ptr i2);
00691
00692
00693
00694
00695 ImageRep_ptr from3Images(ImageRep_ptr i1,
00696 ImageRep_ptr i2,
00697 ImageRep_ptr i3);
00698
00699
00700
00701
00702 ImageRep_ptr fromFile(const char* fileName);
00703 };
00704
00705 }
00706
00707
00708
00709
00710 namespace OBStubImpl_HxCorba
00711 {
00712
00713
00714
00715
00716 class ImageData : virtual public OB::StubImplBase
00717 {
00718 ImageData(const ImageData&);
00719 void operator=(const ImageData&);
00720
00721 protected:
00722
00723 ImageData() { }
00724
00725 public:
00726
00727 static inline ImageData_ptr
00728 _duplicate(ImageData_ptr p)
00729 {
00730 if(p)
00731 p -> _OB_incRef();
00732 return p;
00733 }
00734
00735 static inline ImageData_ptr
00736 _nil()
00737 {
00738 return 0;
00739 }
00740
00741
00742
00743
00744 virtual CORBA::Long dimensionality() = 0;
00745
00746
00747
00748
00749 virtual CORBA::Long numberOfPixels() = 0;
00750
00751
00752
00753
00754 virtual CORBA::Long pixelDimensionality() = 0;
00755
00756
00757
00758
00759 virtual CORBA::Long pixelPrecision() = 0;
00760
00761
00762
00763
00764 virtual HxCorba::PixelT pixelType() = 0;
00765
00766
00767
00768
00769 virtual HxCorba::Sizes getSizes() = 0;
00770
00771
00772
00773
00774 virtual CORBA::Long dimensionSize(CORBA::Long i) = 0;
00775
00776
00777
00778
00779 virtual HxCorba::ImageSignature signature() = 0;
00780
00781
00782
00783
00784 virtual HxCorba::RgbSeq* getRgb2d(const char* displayMode) = 0;
00785
00786
00787
00788
00789 virtual void fillRgb2d(HxCorba::RgbBuffer_ptr buf,
00790 const char* displayMode) = 0;
00791 };
00792
00793
00794
00795
00796 class ImageRep : virtual public OBStubImpl_HxCorba::ImageData,
00797 virtual public OBStubImpl_HxCorba::RefCountBase
00798 {
00799 ImageRep(const ImageRep&);
00800 void operator=(const ImageRep&);
00801
00802 protected:
00803
00804 ImageRep() { }
00805
00806 public:
00807
00808 static inline ImageRep_ptr
00809 _duplicate(ImageRep_ptr p)
00810 {
00811 if(p)
00812 p -> _OB_incRef();
00813 return p;
00814 }
00815
00816 static inline ImageRep_ptr
00817 _nil()
00818 {
00819 return 0;
00820 }
00821
00822
00823
00824
00825 virtual HxCorba::ImageRep_ptr binaryPixOp(HxCorba::ImageRep_ptr arg,
00826 const char* bpoName,
00827 HxCorba::TagList_ptr tags) = 0;
00828
00829
00830
00831
00832 virtual HxCorba::ImageRep_ptr binaryPixOpVal(const HxCorba::PixValue& arg,
00833 const char* bpoName,
00834 HxCorba::TagList_ptr tags) = 0;
00835
00836
00837
00838
00839 virtual HxCorba::ImageRep_ptr unaryPixOp(const char* upoName,
00840 HxCorba::TagList_ptr tags) = 0;
00841
00842
00843
00844
00845 virtual HxCorba::ImageRep_ptr multiPixOp(const HxCorba::ImageList& args,
00846 const char* mpoName,
00847 HxCorba::TagList_ptr tags) = 0;
00848
00849
00850
00851
00852 virtual HxCorba::ImageList* MNPixOp(const HxCorba::ImageList& args,
00853 const char* mpoName,
00854 HxCorba::TagList_ptr tags) = 0;
00855
00856
00857
00858
00859 virtual HxCorba::PixValue reduceOp(const char* op,
00860 HxCorba::TagList_ptr tags) = 0;
00861
00862
00863
00864
00865 virtual HxCorba::ImageRep_ptr generalizedConvolution(HxCorba::ImageRep_ptr kernel,
00866 const char* gMul,
00867 const char* gAdd,
00868 HxCorba::ResultPrecision resPrec,
00869 HxCorba::TagList_ptr tags) = 0;
00870
00871
00872
00873
00874 virtual HxCorba::ImageRep_ptr generalizedConvolutionK1d(CORBA::Long dimension,
00875 HxCorba::ImageRep_ptr kernel,
00876 const char* gMul,
00877 const char* gAdd,
00878 HxCorba::ResultPrecision resPrec,
00879 HxCorba::TagList_ptr tags) = 0;
00880
00881
00882
00883
00884 virtual HxCorba::ImageRep_ptr neighbourhoodOp(const char* ngbName,
00885 HxCorba::TagList_ptr tags) = 0;
00886
00887
00888
00889
00890 virtual HxCorba::ImageRep_ptr recursiveNeighOp(HxCorba::ImageRep_ptr kerImg,
00891 const char* gMul,
00892 const char* gAdd,
00893 HxCorba::TagList_ptr tags,
00894 HxCorba::ResultPrecision resPrec) = 0;
00895
00896
00897
00898
00899 virtual HxCorba::ImageRep_ptr geometricOp2d(HxCorba::Matrix_ptr func,
00900 HxCorba::GeoIntType gi,
00901 HxCorba::GeoTransType gt,
00902 CORBA::Boolean adjustSize,
00903 const HxCorba::PixValue& background) = 0;
00904
00905
00906
00907
00908 virtual HxCorba::ImageRep_ptr scale(CORBA::Double sx,
00909 CORBA::Double sy,
00910 HxCorba::GeoIntType gi) = 0;
00911
00912
00913
00914
00915 virtual HxCorba::PixValue getAt(CORBA::Long x,
00916 CORBA::Long y,
00917 CORBA::Long zz) = 0;
00918 };
00919
00920
00921
00922
00923 class ImageFactory : virtual public OB::StubImplBase
00924 {
00925 ImageFactory(const ImageFactory&);
00926 void operator=(const ImageFactory&);
00927
00928 protected:
00929
00930 ImageFactory() { }
00931
00932 public:
00933
00934 static inline ImageFactory_ptr
00935 _duplicate(ImageFactory_ptr p)
00936 {
00937 if(p)
00938 p -> _OB_incRef();
00939 return p;
00940 }
00941
00942 static inline ImageFactory_ptr
00943 _nil()
00944 {
00945 return 0;
00946 }
00947
00948
00949
00950
00951 virtual HxCorba::ImageRep_ptr importImage(HxCorba::ImageData_ptr data) = 0;
00952
00953
00954
00955
00956 virtual HxCorba::ImageRep_ptr fromSignature(HxCorba::ImageSignature sig,
00957 const HxCorba::Sizes& size) = 0;
00958
00959
00960
00961
00962 virtual HxCorba::ImageRep_ptr fromImage(HxCorba::ImageSignature sig,
00963 HxCorba::ImageRep_ptr src) = 0;
00964
00965
00966
00967
00968 virtual HxCorba::ImageRep_ptr fromValue(HxCorba::ImageSignature sig,
00969 const HxCorba::Sizes& size,
00970 const HxCorba::PixValue& val) = 0;
00971
00972
00973
00974
00975 virtual HxCorba::ImageRep_ptr fromByteData(CORBA::Long pixelDimensionality,
00976 CORBA::Long dimensions,
00977 const HxCorba::Sizes& size,
00978 const HxCorba::OctetSeq& data) = 0;
00979
00980
00981
00982
00983 virtual HxCorba::ImageRep_ptr fromShortData(CORBA::Long pixelDimensionality,
00984 CORBA::Long dimensions,
00985 const HxCorba::Sizes& size,
00986 const HxCorba::ShortSeq& data) = 0;
00987
00988
00989
00990
00991 virtual HxCorba::ImageRep_ptr fromIntData(CORBA::Long pixelDimensionality,
00992 CORBA::Long dimensions,
00993 const HxCorba::Sizes& size,
00994 const HxCorba::LongSeq& data) = 0;
00995
00996
00997
00998
00999 virtual HxCorba::ImageRep_ptr fromFloatData(CORBA::Long pixelDimensionality,
01000 CORBA::Long dimensions,
01001 const HxCorba::Sizes& size,
01002 const HxCorba::FloatSeq& data) = 0;
01003
01004
01005
01006
01007 virtual HxCorba::ImageRep_ptr fromDoubleData(CORBA::Long pixelDimensionality,
01008 CORBA::Long dimensions,
01009 const HxCorba::Sizes& size,
01010 const HxCorba::DoubleSeq& data) = 0;
01011
01012
01013
01014
01015 virtual HxCorba::ImageRep_ptr fromJavaRgb(HxCorba::ImageSignature sig,
01016 const HxCorba::Sizes& size,
01017 const HxCorba::RgbSeq& pixels) = 0;
01018
01019
01020
01021
01022 virtual HxCorba::ImageRep_ptr fromGrayValue(HxCorba::ImageSignature sig,
01023 const HxCorba::Sizes& size,
01024 const HxCorba::OctetSeq& pixels) = 0;
01025
01026
01027
01028
01029 virtual HxCorba::ImageRep_ptr fromMatlab(HxCorba::ImageSignature sig,
01030 const HxCorba::Sizes& size,
01031 const HxCorba::DoubleSeq& pixels) = 0;
01032
01033
01034
01035
01036 virtual HxCorba::ImageRep_ptr fromNamedGenerator(HxCorba::ImageSignature sig,
01037 const char* generatorName,
01038 HxCorba::TagList_ptr tags) = 0;
01039
01040
01041
01042
01043 virtual HxCorba::ImageRep_ptr fromImport(HxCorba::ImageSignature sig,
01044 const HxCorba::Sizes& size,
01045 const char* importOp,
01046 HxCorba::TagList_ptr tags) = 0;
01047
01048
01049
01050
01051 virtual HxCorba::ImageRep_ptr from2Images(HxCorba::ImageRep_ptr i1,
01052 HxCorba::ImageRep_ptr i2) = 0;
01053
01054
01055
01056
01057 virtual HxCorba::ImageRep_ptr from3Images(HxCorba::ImageRep_ptr i1,
01058 HxCorba::ImageRep_ptr i2,
01059 HxCorba::ImageRep_ptr i3) = 0;
01060
01061
01062
01063
01064 virtual HxCorba::ImageRep_ptr fromFile(const char* fileName) = 0;
01065 };
01066
01067 }
01068
01069
01070
01071
01072 namespace OBMarshalStubImpl_HxCorba
01073 {
01074
01075
01076
01077
01078 class ImageData : virtual public OBStubImpl_HxCorba::ImageData,
01079 virtual public OB::MarshalStubImpl
01080 {
01081 ImageData(const ImageData&);
01082 void operator=(const ImageData&);
01083
01084 protected:
01085
01086 ImageData() { }
01087 friend class HxCorba::ImageData;
01088
01089 public:
01090
01091
01092
01093
01094 virtual CORBA::Long dimensionality();
01095
01096
01097
01098
01099 virtual CORBA::Long numberOfPixels();
01100
01101
01102
01103
01104 virtual CORBA::Long pixelDimensionality();
01105
01106
01107
01108
01109 virtual CORBA::Long pixelPrecision();
01110
01111
01112
01113
01114 virtual HxCorba::PixelT pixelType();
01115
01116
01117
01118
01119 virtual HxCorba::Sizes getSizes();
01120
01121
01122
01123
01124 virtual CORBA::Long dimensionSize(CORBA::Long i);
01125
01126
01127
01128
01129 virtual HxCorba::ImageSignature signature();
01130
01131
01132
01133
01134 virtual HxCorba::RgbSeq* getRgb2d(const char* displayMode);
01135
01136
01137
01138
01139 virtual void fillRgb2d(HxCorba::RgbBuffer_ptr buf,
01140 const char* displayMode);
01141 };
01142
01143
01144
01145
01146 class ImageRep : virtual public OBStubImpl_HxCorba::ImageRep,
01147 virtual public OBMarshalStubImpl_HxCorba::ImageData,
01148 virtual public OBMarshalStubImpl_HxCorba::RefCountBase
01149 {
01150 ImageRep(const ImageRep&);
01151 void operator=(const ImageRep&);
01152
01153 protected:
01154
01155 ImageRep() { }
01156 friend class HxCorba::ImageRep;
01157
01158 public:
01159
01160
01161
01162
01163 virtual HxCorba::ImageRep_ptr binaryPixOp(HxCorba::ImageRep_ptr arg,
01164 const char* bpoName,
01165 HxCorba::TagList_ptr tags);
01166
01167
01168
01169
01170 virtual HxCorba::ImageRep_ptr binaryPixOpVal(const HxCorba::PixValue& arg,
01171 const char* bpoName,
01172 HxCorba::TagList_ptr tags);
01173
01174
01175
01176
01177 virtual HxCorba::ImageRep_ptr unaryPixOp(const char* upoName,
01178 HxCorba::TagList_ptr tags);
01179
01180
01181
01182
01183 virtual HxCorba::ImageRep_ptr multiPixOp(const HxCorba::ImageList& args,
01184 const char* mpoName,
01185 HxCorba::TagList_ptr tags);
01186
01187
01188
01189
01190 virtual HxCorba::ImageList* MNPixOp(const HxCorba::ImageList& args,
01191 const char* mpoName,
01192 HxCorba::TagList_ptr tags);
01193
01194
01195
01196
01197 virtual HxCorba::PixValue reduceOp(const char* op,
01198 HxCorba::TagList_ptr tags);
01199
01200
01201
01202
01203 virtual HxCorba::ImageRep_ptr generalizedConvolution(HxCorba::ImageRep_ptr kernel,
01204 const char* gMul,
01205 const char* gAdd,
01206 HxCorba::ResultPrecision resPrec,
01207 HxCorba::TagList_ptr tags);
01208
01209
01210
01211
01212 virtual HxCorba::ImageRep_ptr generalizedConvolutionK1d(CORBA::Long dimension,
01213 HxCorba::ImageRep_ptr kernel,
01214 const char* gMul,
01215 const char* gAdd,
01216 HxCorba::ResultPrecision resPrec,
01217 HxCorba::TagList_ptr tags);
01218
01219
01220
01221
01222 virtual HxCorba::ImageRep_ptr neighbourhoodOp(const char* ngbName,
01223 HxCorba::TagList_ptr tags);
01224
01225
01226
01227
01228 virtual HxCorba::ImageRep_ptr recursiveNeighOp(HxCorba::ImageRep_ptr kerImg,
01229 const char* gMul,
01230 const char* gAdd,
01231 HxCorba::TagList_ptr tags,
01232 HxCorba::ResultPrecision resPrec);
01233
01234
01235
01236
01237 virtual HxCorba::ImageRep_ptr geometricOp2d(HxCorba::Matrix_ptr func,
01238 HxCorba::GeoIntType gi,
01239 HxCorba::GeoTransType gt,
01240 CORBA::Boolean adjustSize,
01241 const HxCorba::PixValue& background);
01242
01243
01244
01245
01246 virtual HxCorba::ImageRep_ptr scale(CORBA::Double sx,
01247 CORBA::Double sy,
01248 HxCorba::GeoIntType gi);
01249
01250
01251
01252
01253 virtual HxCorba::PixValue getAt(CORBA::Long x,
01254 CORBA::Long y,
01255 CORBA::Long zz);
01256 };
01257
01258
01259
01260
01261 class ImageFactory : virtual public OBStubImpl_HxCorba::ImageFactory,
01262 virtual public OB::MarshalStubImpl
01263 {
01264 ImageFactory(const ImageFactory&);
01265 void operator=(const ImageFactory&);
01266
01267 protected:
01268
01269 ImageFactory() { }
01270 friend class HxCorba::ImageFactory;
01271
01272 public:
01273
01274
01275
01276
01277 virtual HxCorba::ImageRep_ptr importImage(HxCorba::ImageData_ptr data);
01278
01279
01280
01281
01282 virtual HxCorba::ImageRep_ptr fromSignature(HxCorba::ImageSignature sig,
01283 const HxCorba::Sizes& size);
01284
01285
01286
01287
01288 virtual HxCorba::ImageRep_ptr fromImage(HxCorba::ImageSignature sig,
01289 HxCorba::ImageRep_ptr src);
01290
01291
01292
01293
01294 virtual HxCorba::ImageRep_ptr fromValue(HxCorba::ImageSignature sig,
01295 const HxCorba::Sizes& size,
01296 const HxCorba::PixValue& val);
01297
01298
01299
01300
01301 virtual HxCorba::ImageRep_ptr fromByteData(CORBA::Long pixelDimensionality,
01302 CORBA::Long dimensions,
01303 const HxCorba::Sizes& size,
01304 const HxCorba::OctetSeq& data);
01305
01306
01307
01308
01309 virtual HxCorba::ImageRep_ptr fromShortData(CORBA::Long pixelDimensionality,
01310 CORBA::Long dimensions,
01311 const HxCorba::Sizes& size,
01312 const HxCorba::ShortSeq& data);
01313
01314
01315
01316
01317 virtual HxCorba::ImageRep_ptr fromIntData(CORBA::Long pixelDimensionality,
01318 CORBA::Long dimensions,
01319 const HxCorba::Sizes& size,
01320 const HxCorba::LongSeq& data);
01321
01322
01323
01324
01325 virtual HxCorba::ImageRep_ptr fromFloatData(CORBA::Long pixelDimensionality,
01326 CORBA::Long dimensions,
01327 const HxCorba::Sizes& size,
01328 const HxCorba::FloatSeq& data);
01329
01330
01331
01332
01333 virtual HxCorba::ImageRep_ptr fromDoubleData(CORBA::Long pixelDimensionality,
01334 CORBA::Long dimensions,
01335 const HxCorba::Sizes& size,
01336 const HxCorba::DoubleSeq& data);
01337
01338
01339
01340
01341 virtual HxCorba::ImageRep_ptr fromJavaRgb(HxCorba::ImageSignature sig,
01342 const HxCorba::Sizes& size,
01343 const HxCorba::RgbSeq& pixels);
01344
01345
01346
01347
01348 virtual HxCorba::ImageRep_ptr fromGrayValue(HxCorba::ImageSignature sig,
01349 const HxCorba::Sizes& size,
01350 const HxCorba::OctetSeq& pixels);
01351
01352
01353
01354
01355 virtual HxCorba::ImageRep_ptr fromMatlab(HxCorba::ImageSignature sig,
01356 const HxCorba::Sizes& size,
01357 const HxCorba::DoubleSeq& pixels);
01358
01359
01360
01361
01362 virtual HxCorba::ImageRep_ptr fromNamedGenerator(HxCorba::ImageSignature sig,
01363 const char* generatorName,
01364 HxCorba::TagList_ptr tags);
01365
01366
01367
01368
01369 virtual HxCorba::ImageRep_ptr fromImport(HxCorba::ImageSignature sig,
01370 const HxCorba::Sizes& size,
01371 const char* importOp,
01372 HxCorba::TagList_ptr tags);
01373
01374
01375
01376
01377 virtual HxCorba::ImageRep_ptr from2Images(HxCorba::ImageRep_ptr i1,
01378 HxCorba::ImageRep_ptr i2);
01379
01380
01381
01382
01383 virtual HxCorba::ImageRep_ptr from3Images(HxCorba::ImageRep_ptr i1,
01384 HxCorba::ImageRep_ptr i2,
01385 HxCorba::ImageRep_ptr i3);
01386
01387
01388
01389
01390 virtual HxCorba::ImageRep_ptr fromFile(const char* fileName);
01391 };
01392
01393 }
01394
01395
01396
01397
01398 namespace OBV_HxCorba
01399 {
01400
01401 }
01402
01403
01404
01405
01406 void operator<<=(CORBA::Any&, HxCorba::PixelT);
01407 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::PixelT&);
01408
01409 inline void
01410 operator<<=(CORBA::Any_var& any, HxCorba::PixelT val)
01411 {
01412 any.inout() <<= val;
01413 }
01414
01415 inline CORBA::Boolean
01416 operator>>=(const CORBA::Any_var& any, HxCorba::PixelT& val)
01417 {
01418 return any.in() >>= val;
01419 }
01420
01421
01422
01423
01424 void operator<<=(CORBA::Any&, HxCorba::ImageSignature);
01425 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageSignature&);
01426
01427 inline void
01428 operator<<=(CORBA::Any_var& any, HxCorba::ImageSignature val)
01429 {
01430 any.inout() <<= val;
01431 }
01432
01433 inline CORBA::Boolean
01434 operator>>=(const CORBA::Any_var& any, HxCorba::ImageSignature& val)
01435 {
01436 return any.in() >>= val;
01437 }
01438
01439
01440
01441
01442 void operator<<=(CORBA::Any&, HxCorba::Sizes*);
01443 void operator<<=(CORBA::Any&, const HxCorba::Sizes&);
01444 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::Sizes*&);
01445
01446 inline void
01447 operator<<=(CORBA::Any_var& any, HxCorba::Sizes* val)
01448 {
01449 any.inout() <<= val;
01450 }
01451
01452 inline void
01453 operator<<=(CORBA::Any_var& any, const HxCorba::Sizes& val)
01454 {
01455 any.inout() <<= val;
01456 }
01457
01458 inline CORBA::Boolean
01459 operator>>=(const CORBA::Any_var& any, const HxCorba::Sizes*& val)
01460 {
01461 return any.in() >>= val;
01462 }
01463
01464
01465
01466
01467 void operator<<=(CORBA::Any&, HxCorba::Point*);
01468 void operator<<=(CORBA::Any&, const HxCorba::Point&);
01469 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::Point*&);
01470
01471 inline void
01472 operator<<=(CORBA::Any_var& any, HxCorba::Point* val)
01473 {
01474 any.inout() <<= val;
01475 }
01476
01477 inline void
01478 operator<<=(CORBA::Any_var& any, const HxCorba::Point& val)
01479 {
01480 any.inout() <<= val;
01481 }
01482
01483 inline CORBA::Boolean
01484 operator>>=(const CORBA::Any_var& any, const HxCorba::Point*& val)
01485 {
01486 return any.in() >>= val;
01487 }
01488
01489
01490
01491
01492 namespace CORBA
01493 {
01494
01495 inline void
01496 release(HxCorba::ImageData_ptr p)
01497 {
01498 if(p)
01499 p -> _OB_decRef();
01500 }
01501
01502 inline Boolean
01503 is_nil(HxCorba::ImageData_ptr p)
01504 {
01505 return p == 0;
01506 }
01507
01508 inline void
01509 release(OBStubImpl_HxCorba::ImageData_ptr p)
01510 {
01511 if(p)
01512 p -> _OB_decRef();
01513 }
01514
01515 inline Boolean
01516 is_nil(OBStubImpl_HxCorba::ImageData_ptr p)
01517 {
01518 return p == 0;
01519 }
01520
01521 }
01522
01523 void operator<<=(CORBA::Any&, HxCorba::ImageData_ptr*);
01524 void operator<<=(CORBA::Any&, HxCorba::ImageData_ptr);
01525 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageData_ptr&);
01526
01527 inline void
01528 operator<<=(CORBA::Any_var& any, HxCorba::ImageData_ptr* val)
01529 {
01530 any.inout() <<= val;
01531 }
01532
01533 inline void
01534 operator<<=(CORBA::Any_var& any, HxCorba::ImageData_ptr val)
01535 {
01536 any.inout() <<= val;
01537 }
01538
01539 inline CORBA::Boolean
01540 operator>>=(const CORBA::Any_var& any, HxCorba::ImageData_ptr& val)
01541 {
01542 return any.in() >>= val;
01543 }
01544
01545
01546
01547
01548 void operator<<=(CORBA::Any&, HxCorba::GeoIntType);
01549 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::GeoIntType&);
01550
01551 inline void
01552 operator<<=(CORBA::Any_var& any, HxCorba::GeoIntType val)
01553 {
01554 any.inout() <<= val;
01555 }
01556
01557 inline CORBA::Boolean
01558 operator>>=(const CORBA::Any_var& any, HxCorba::GeoIntType& val)
01559 {
01560 return any.in() >>= val;
01561 }
01562
01563
01564
01565
01566 void operator<<=(CORBA::Any&, HxCorba::GeoTransType);
01567 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::GeoTransType&);
01568
01569 inline void
01570 operator<<=(CORBA::Any_var& any, HxCorba::GeoTransType val)
01571 {
01572 any.inout() <<= val;
01573 }
01574
01575 inline CORBA::Boolean
01576 operator>>=(const CORBA::Any_var& any, HxCorba::GeoTransType& val)
01577 {
01578 return any.in() >>= val;
01579 }
01580
01581
01582
01583
01584 void operator<<=(CORBA::Any&, HxCorba::ResultPrecision);
01585 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ResultPrecision&);
01586
01587 inline void
01588 operator<<=(CORBA::Any_var& any, HxCorba::ResultPrecision val)
01589 {
01590 any.inout() <<= val;
01591 }
01592
01593 inline CORBA::Boolean
01594 operator>>=(const CORBA::Any_var& any, HxCorba::ResultPrecision& val)
01595 {
01596 return any.in() >>= val;
01597 }
01598
01599
01600
01601
01602 void operator<<=(CORBA::Any&, HxCorba::ImageException*);
01603 void operator<<=(CORBA::Any&, const HxCorba::ImageException&);
01604 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::ImageException*&);
01605
01606 inline void
01607 operator<<=(CORBA::Any_var& any, HxCorba::ImageException* val)
01608 {
01609 any.inout() <<= val;
01610 }
01611
01612 inline void
01613 operator<<=(CORBA::Any_var& any, const HxCorba::ImageException& val)
01614 {
01615 any.inout() <<= val;
01616 }
01617
01618 inline CORBA::Boolean
01619 operator>>=(const CORBA::Any_var& any, const HxCorba::ImageException*& val)
01620 {
01621 return any.in() >>= val;
01622 }
01623
01624
01625
01626
01627 void operator<<=(CORBA::Any&, HxCorba::ImageList*);
01628 void operator<<=(CORBA::Any&, const HxCorba::ImageList&);
01629 CORBA::Boolean operator>>=(const CORBA::Any&, const HxCorba::ImageList*&);
01630
01631 inline void
01632 operator<<=(CORBA::Any_var& any, HxCorba::ImageList* val)
01633 {
01634 any.inout() <<= val;
01635 }
01636
01637 inline void
01638 operator<<=(CORBA::Any_var& any, const HxCorba::ImageList& val)
01639 {
01640 any.inout() <<= val;
01641 }
01642
01643 inline CORBA::Boolean
01644 operator>>=(const CORBA::Any_var& any, const HxCorba::ImageList*& val)
01645 {
01646 return any.in() >>= val;
01647 }
01648
01649
01650
01651
01652 namespace CORBA
01653 {
01654
01655 inline void
01656 release(HxCorba::ImageRep_ptr p)
01657 {
01658 if(p)
01659 p -> _OB_decRef();
01660 }
01661
01662 inline Boolean
01663 is_nil(HxCorba::ImageRep_ptr p)
01664 {
01665 return p == 0;
01666 }
01667
01668 inline void
01669 release(OBStubImpl_HxCorba::ImageRep_ptr p)
01670 {
01671 if(p)
01672 p -> _OB_decRef();
01673 }
01674
01675 inline Boolean
01676 is_nil(OBStubImpl_HxCorba::ImageRep_ptr p)
01677 {
01678 return p == 0;
01679 }
01680
01681 }
01682
01683 void operator<<=(CORBA::Any&, HxCorba::ImageRep_ptr*);
01684 void operator<<=(CORBA::Any&, HxCorba::ImageRep_ptr);
01685 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageRep_ptr&);
01686
01687 inline void
01688 operator<<=(CORBA::Any_var& any, HxCorba::ImageRep_ptr* val)
01689 {
01690 any.inout() <<= val;
01691 }
01692
01693 inline void
01694 operator<<=(CORBA::Any_var& any, HxCorba::ImageRep_ptr val)
01695 {
01696 any.inout() <<= val;
01697 }
01698
01699 inline CORBA::Boolean
01700 operator>>=(const CORBA::Any_var& any, HxCorba::ImageRep_ptr& val)
01701 {
01702 return any.in() >>= val;
01703 }
01704
01705
01706
01707
01708 namespace CORBA
01709 {
01710
01711 inline void
01712 release(HxCorba::ImageFactory_ptr p)
01713 {
01714 if(p)
01715 p -> _OB_decRef();
01716 }
01717
01718 inline Boolean
01719 is_nil(HxCorba::ImageFactory_ptr p)
01720 {
01721 return p == 0;
01722 }
01723
01724 inline void
01725 release(OBStubImpl_HxCorba::ImageFactory_ptr p)
01726 {
01727 if(p)
01728 p -> _OB_decRef();
01729 }
01730
01731 inline Boolean
01732 is_nil(OBStubImpl_HxCorba::ImageFactory_ptr p)
01733 {
01734 return p == 0;
01735 }
01736
01737 }
01738
01739 void operator<<=(CORBA::Any&, HxCorba::ImageFactory_ptr*);
01740 void operator<<=(CORBA::Any&, HxCorba::ImageFactory_ptr);
01741 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::ImageFactory_ptr&);
01742
01743 inline void
01744 operator<<=(CORBA::Any_var& any, HxCorba::ImageFactory_ptr* val)
01745 {
01746 any.inout() <<= val;
01747 }
01748
01749 inline void
01750 operator<<=(CORBA::Any_var& any, HxCorba::ImageFactory_ptr val)
01751 {
01752 any.inout() <<= val;
01753 }
01754
01755 inline CORBA::Boolean
01756 operator>>=(const CORBA::Any_var& any, HxCorba::ImageFactory_ptr& val)
01757 {
01758 return any.in() >>= val;
01759 }
01760
01761 #endif