OSDN -- Develop and Download Open Source Software
  • R/O
  • HTTP
  • SSH
  • HTTPS
Fork

base: Commit

This repository is a base of Eos.


Commit MetaInfo

Revision06307c067cddd63da8b4f9f68883c4ef94878378 (tree)
Time2014-11-01 16:40:20
AuthorTakuo Yasunaga <yasunaga@bio....>
CommiterTakuo Yasunaga

Log Message

Rebuld:
modified: hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageAutoCorrelationWithWindowing
modified: hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageCTFCompensationForTiltImage
copied: hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageNormalizedSubtraction/src/X86LINUX64/mrcImageNormalizedSubtraction -> hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageNormalizedSubtraction
modified: hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageSpatialFrequencyFilter
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libArray.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libEosObjects.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libTclTk.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libctfInfo.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libgifFile.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libllData.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libmrcImage.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libpdbFile.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/libtransform.a
modified: hostdepend/X86LINUX64/lib/X86LINUX64/shared/lmrcImageSpatialFrequencyFilter.sharedo
modified: hostdepend/X86LINUX64/src/Objects/DataExpress/TclTk/src/X86LINUX64/libTclTk.a
modified: hostdepend/X86LINUX64/src/Objects/DataExpress/gifFile/src/X86LINUX64/libgifFile.a
modified: hostdepend/X86LINUX64/src/Objects/DataManip/ctfInfo/src/X86LINUX64/libctfInfo.a
modified: hostdepend/X86LINUX64/src/Objects/DataManip/llData/src/X86LINUX64/libllData.a
modified: hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/libmrcImage.a
modified: hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/libmrcImage.debug.a
modified: hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/lmrcImageSpatialFrequencyFilter.sharedo
modified: hostdepend/X86LINUX64/src/Objects/DataManip/pdbFile/src/X86LINUX64/libpdbFile.a
modified: hostdepend/X86LINUX64/src/Objects/DataManip/transform/src/X86LINUX64/libtransform.a
modified: hostdepend/X86LINUX64/src/Objects/General/Array/src/X86LINUX64/libArray.a
new file: hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageAutoCorrelationWithWindowing/src/X86LINUX64/mrcImageAutoCorrelationWithWindowing
modified: hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageCTFCompensationForTiltImage/src/X86LINUX64/mrcImageCTFCompensationForTiltImage
modified: hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageNormalizedSubtraction/src/X86LINUX64/mrcImageNormalizedSubtraction
modified: hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageSpatialFrequencyFilter/src/X86LINUX64/mrcImageSpatialFrequencyFilter
modified: src/Objects/DataExpress/eosRuby/src/Swig/molvieRuby_wrap.c
modified: src/Tools/Integration/Display2/src/Display2.html
modified: src/Tools/mrcImage/mrcImageAutoCorrelationWithWindowing/src/mrcImageAutoCorrelationWithWindowing.html
modified: src/Tools/mrcImage/mrcImageDensityInfo/src/mrcImageDensityInfo.html
typechange: src/Tools/mrcImage/mrcImageNormalizedSubtraction/Makefile
modified: src/Tools/mrcImage/mrcImageSplit/src/mrcImageSplit.html

Change Summary

Incremental Difference

--- a/bin/wish/Display2/tclIndex
+++ b/bin/wish/Display2/tclIndex
@@ -6,38 +6,41 @@
66 # element name is the name of a command and the value is
77 # a script that loads the command.
88
9-set auto_index(roiAreaRotateStart) [list source [file join $dir RoiAreaRotate.wish]]
10-set auto_index(roiAreaRotateMotion) [list source [file join $dir RoiAreaRotate.wish]]
11-set auto_index(roiAreaRotateEnd) [list source [file join $dir RoiAreaRotate.wish]]
12-set auto_index(rectangleRotate) [list source [file join $dir RoiAreaRotate.wish]]
13-set auto_index(rectangleRotateCalc) [list source [file join $dir RoiAreaRotate.wish]]
14-set auto_index(lineRotate) [list source [file join $dir RoiAreaRotate.wish]]
15-set auto_index(lineRotateCalc) [list source [file join $dir RoiAreaRotate.wish]]
16-set auto_index(splineRotate) [list source [file join $dir RoiAreaRotate.wish]]
17-set auto_index(splineRotateCalc) [list source [file join $dir RoiAreaRotate.wish]]
18-set auto_index(roiAreaSelectStart) [list source [file join $dir RoiAreaSelect.wish]]
19-set auto_index(roiAreaSelectMotion) [list source [file join $dir RoiAreaSelect.wish]]
20-set auto_index(roiAreaSelectEnd) [list source [file join $dir RoiAreaSelect.wish]]
21-set auto_index(roiAreaSelectOK) [list source [file join $dir RoiAreaSelect.wish]]
9+set auto_index(display2BindingSet) [list source [file join $dir Display2Binding.wish]]
2210 set auto_index(colormapChange) [list source [file join $dir Display2Colormap.wish]]
11+set auto_index(display2DesktopSet) [list source [file join $dir Display2Desktop.wish]]
12+set auto_index(display2ETCSet) [list source [file join $dir Display2ETCSet.wish]]
13+set auto_index(fileOpenWinCreate) [list source [file join $dir Display2File.wish]]
14+set auto_index(fileNewWinCreate) [list source [file join $dir Display2File.wish]]
15+set auto_index(seqFileOpenWinCreate) [list source [file join $dir Display2File.wish]]
16+set auto_index(seqFileNewWinCreate) [list source [file join $dir Display2File.wish]]
17+set auto_index(fileOpen) [list source [file join $dir Display2Image.wish]]
18+set auto_index(mainImagePut) [list source [file join $dir Display2Image.wish]]
19+set auto_index(overviewImagePut) [list source [file join $dir Display2Image.wish]]
20+set auto_index(histgramGraphCreate) [list source [file join $dir Display2Info.wish]]
21+set auto_index(display2InformationWinCreate) [list source [file join $dir Display2Info.wish]]
22+set auto_index(fileReopen) [list source [file join $dir Display2Info.wish]]
23+set auto_index(mrcImageInformationWinCreate) [list source [file join $dir Display2Info.wish]]
24+set auto_index(imageInformationWinCreate) [list source [file join $dir Display2Info.wish]]
25+set auto_index(layerLineInformationWinCreate) [list source [file join $dir Display2Info.wish]]
26+set auto_index(projectionInformationWinCreate) [list source [file join $dir Display2Info.wish]]
27+set auto_index(sectionInformationWinCreate) [list source [file join $dir Display2Info.wish]]
28+set auto_index(ctfInformationWinCreate) [list source [file join $dir Display2Info.wish]]
29+set auto_index(unitCellInformationWinCreate) [list source [file join $dir Display2Info.wish]]
30+set auto_index(scaleInfoWinCreate) [list source [file join $dir Display2Info.wish]]
31+set auto_index(roiInformationWinCreate) [list source [file join $dir Display2InfoROI.wish]]
32+set auto_index(roiLineInfoFrameCreate) [list source [file join $dir Display2InfoROI.wish]]
33+set auto_index(roiSplineInfoFrameCreate) [list source [file join $dir Display2InfoROI.wish]]
34+set auto_index(roiRectangleInfoFrameCreate) [list source [file join $dir Display2InfoROI.wish]]
35+set auto_index(roiAnalysisFrameCreate) [list source [file join $dir Display2InfoROI.wish]]
36+set auto_index(display2Init) [list source [file join $dir Display2Init.wish]]
37+set auto_index(display2MenuSet) [list source [file join $dir Display2Menu.wish]]
38+set auto_index(menuFileCreate) [list source [file join $dir Display2Menu.wish]]
39+set auto_index(menuSeqFileCreate) [list source [file join $dir Display2Menu.wish]]
40+set auto_index(menuWindowCreate) [list source [file join $dir Display2Menu.wish]]
41+set auto_index(menuInfoCreate) [list source [file join $dir Display2Menu.wish]]
42+set auto_index(menuHelpCreate) [list source [file join $dir Display2Menu.wish]]
2343 set auto_index(display2MenuSet2) [list source [file join $dir Display2Menu2.wish]]
24-set auto_index(fft2dCmd) [list source [file join $dir fft2dCmd.wish]]
25-set auto_index(display2BindingSet) [list source [file join $dir Display2Binding.wish]]
26-set auto_index(roiMultiAreaInfoSave) [list source [file join $dir RoiAreaFile.wish]]
27-set auto_index(roiMultiAreaInfoLoad) [list source [file join $dir RoiAreaFile.wish]]
28-set auto_index(roiAreaFileSave) [list source [file join $dir RoiAreaFile.wish]]
29-set auto_index(roiAreaFFT) [list source [file join $dir RoiAreaUtil.wish]]
30-set auto_index(splineNearPoint) [list source [file join $dir RoiAreaUtil.wish]]
31-set auto_index(rectangleNearPoint) [list source [file join $dir RoiAreaUtil.wish]]
32-set auto_index(lineNearPoint) [list source [file join $dir RoiAreaUtil.wish]]
33-set auto_index(pointDistance) [list source [file join $dir RoiAreaUtil.wish]]
34-set auto_index(pointDistance2) [list source [file join $dir RoiAreaUtil.wish]]
35-set auto_index(vectorAngle) [list source [file join $dir RoiAreaUtil.wish]]
36-set auto_index(coordGetInMainImageToReal) [list source [file join $dir RoiAreaUtil.wish]]
37-set auto_index(coordGetInMainImageToCanvas) [list source [file join $dir RoiAreaUtil.wish]]
38-set auto_index(dataGetInMainImageToReal) [list source [file join $dir RoiAreaUtil.wish]]
39-set auto_index(dataGetInMainImageToCanvas) [list source [file join $dir RoiAreaUtil.wish]]
40-set auto_index(pointSet) [list source [file join $dir RoiAreaUtil.wish]]
4144 set auto_index(roiRelatedObjectRecreate) [list source [file join $dir Display2MenuROI.wish]]
4245 set auto_index(menuRoiCreate) [list source [file join $dir Display2MenuROI.wish]]
4346 set auto_index(menuRoiCancelCommand) [list source [file join $dir Display2MenuROI.wish]]
@@ -46,39 +49,14 @@ set auto_index(menuMultiRoiOKCommand) [list source [file join $dir Display2MenuR
4649 set auto_index(menuMultiRoiAllDeleteCommand) [list source [file join $dir Display2MenuROI.wish]]
4750 set auto_index(menuMultiRoiDeleteCommand) [list source [file join $dir Display2MenuROI.wish]]
4851 set auto_index(menuEditCreate) [list source [file join $dir Display2MenuROI.wish]]
49-set auto_index(display2Init) [list source [file join $dir Display2Init.wish]]
50-set auto_index(display2MenuSet) [list source [file join $dir Display2Menu.wish]]
51-set auto_index(menuFileCreate) [list source [file join $dir Display2Menu.wish]]
52-set auto_index(menuSeqFileCreate) [list source [file join $dir Display2Menu.wish]]
53-set auto_index(menuWindowCreate) [list source [file join $dir Display2Menu.wish]]
54-set auto_index(menuInfoCreate) [list source [file join $dir Display2Menu.wish]]
55-set auto_index(menuHelpCreate) [list source [file join $dir Display2Menu.wish]]
56-set auto_index(roiAreaResizeStart) [list source [file join $dir RoiAreaResize.wish]]
57-set auto_index(roiAreaResizeMotion) [list source [file join $dir RoiAreaResize.wish]]
58-set auto_index(roiAreaResizeEnd) [list source [file join $dir RoiAreaResize.wish]]
59-set auto_index(rectangleResize) [list source [file join $dir RoiAreaResize.wish]]
60-set auto_index(rectangleResizeCalc) [list source [file join $dir RoiAreaResize.wish]]
61-set auto_index(lineResize) [list source [file join $dir RoiAreaResize.wish]]
62-set auto_index(splineResize) [list source [file join $dir RoiAreaResize.wish]]
63-set auto_index(fft2dCmd) [list source [file join $dir fft2dCmd.wish]]
6452 set auto_index(layerLineRecreate) [list source [file join $dir LayerLineUtil.wish]]
6553 set auto_index(layerLineCreate) [list source [file join $dir LayerLineUtil.wish]]
6654 set auto_index(layerLineClear) [list source [file join $dir LayerLineUtil.wish]]
6755 set auto_index(layerLineChange) [list source [file join $dir LayerLineUtil.wish]]
68-set auto_index(histgramGraphCreate) [list source [file join $dir Display2Info.wish]]
69-set auto_index(display2InformationWinCreate) [list source [file join $dir Display2Info.wish]]
70-set auto_index(fileReopen) [list source [file join $dir Display2Info.wish]]
71-set auto_index(mrcImageInformationWinCreate) [list source [file join $dir Display2Info.wish]]
72-set auto_index(imageInformationWinCreate) [list source [file join $dir Display2Info.wish]]
73-set auto_index(layerLineInformationWinCreate) [list source [file join $dir Display2Info.wish]]
74-set auto_index(projectionInformationWinCreate) [list source [file join $dir Display2Info.wish]]
75-set auto_index(sectionInformationWinCreate) [list source [file join $dir Display2Info.wish]]
76-set auto_index(ctfInformationWinCreate) [list source [file join $dir Display2Info.wish]]
77-set auto_index(unitCellInformationWinCreate) [list source [file join $dir Display2Info.wish]]
78-set auto_index(scaleInfoWinCreate) [list source [file join $dir Display2Info.wish]]
79-set auto_index(roiAreaZoomIn) [list source [file join $dir RoiAreaZoom.wish]]
80-set auto_index(roiAreaZoomOut) [list source [file join $dir RoiAreaZoom.wish]]
81-set auto_index(roiAreaZoom) [list source [file join $dir RoiAreaZoom.wish]]
56+set auto_index(projectionRecreate) [list source [file join $dir ProjectionUtil.wish]]
57+set auto_index(projectionCreate) [list source [file join $dir ProjectionUtil.wish]]
58+set auto_index(projectionClear) [list source [file join $dir ProjectionUtil.wish]]
59+set auto_index(projectionChange) [list source [file join $dir ProjectionUtil.wish]]
8260 set auto_index(roiAreaCreateStart) [list source [file join $dir RoiAreaCreate.wish]]
8361 set auto_index(roiAreaCreateMotion) [list source [file join $dir RoiAreaCreate.wish]]
8462 set auto_index(roiAreaCreateEnd) [list source [file join $dir RoiAreaCreate.wish]]
@@ -96,29 +74,54 @@ set auto_index(roiSplineEnd) [list source [file join $dir RoiAreaCreate.wish]]
9674 set auto_index(splineCreate) [list source [file join $dir RoiAreaCreate.wish]]
9775 set auto_index(knobShow) [list source [file join $dir RoiAreaCreate.wish]]
9876 set auto_index(knobHide) [list source [file join $dir RoiAreaCreate.wish]]
99-set auto_index(fileOpenWinCreate) [list source [file join $dir Display2File.wish]]
100-set auto_index(fileNewWinCreate) [list source [file join $dir Display2File.wish]]
101-set auto_index(seqFileOpenWinCreate) [list source [file join $dir Display2File.wish]]
102-set auto_index(seqFileNewWinCreate) [list source [file join $dir Display2File.wish]]
103-set auto_index(ScaleRecreate) [list source [file join $dir ScaleUtil.wish]]
104-set auto_index(ScaleCreate) [list source [file join $dir ScaleUtil.wish]]
105-set auto_index(ScaleClear) [list source [file join $dir ScaleUtil.wish]]
106-set auto_index(ScaleChange) [list source [file join $dir ScaleUtil.wish]]
107-set auto_index(unitCellRecreate) [list source [file join $dir UnitCell.wish]]
108-set auto_index(fileOpen) [list source [file join $dir Display2Image.wish]]
109-set auto_index(mainImagePut) [list source [file join $dir Display2Image.wish]]
110-set auto_index(overviewImagePut) [list source [file join $dir Display2Image.wish]]
77+set auto_index(roiMultiAreaInfoSave) [list source [file join $dir RoiAreaFile.wish]]
78+set auto_index(roiMultiAreaInfoLoad) [list source [file join $dir RoiAreaFile.wish]]
79+set auto_index(roiAreaFileSave) [list source [file join $dir RoiAreaFile.wish]]
11180 set auto_index(roiAreaMoveStart) [list source [file join $dir RoiAreaMove.wish]]
11281 set auto_index(roiAreaMoveMotion) [list source [file join $dir RoiAreaMove.wish]]
11382 set auto_index(roiAreaMoveEnd) [list source [file join $dir RoiAreaMove.wish]]
11483 set auto_index(rectangleMove) [list source [file join $dir RoiAreaMove.wish]]
11584 set auto_index(lineMove) [list source [file join $dir RoiAreaMove.wish]]
11685 set auto_index(splineMove) [list source [file join $dir RoiAreaMove.wish]]
117-set auto_index(roiInformationWinCreate) [list source [file join $dir Display2InfoROI.wish]]
118-set auto_index(roiLineInfoFrameCreate) [list source [file join $dir Display2InfoROI.wish]]
119-set auto_index(roiSplineInfoFrameCreate) [list source [file join $dir Display2InfoROI.wish]]
120-set auto_index(roiRectangleInfoFrameCreate) [list source [file join $dir Display2InfoROI.wish]]
121-set auto_index(roiAnalysisFrameCreate) [list source [file join $dir Display2InfoROI.wish]]
86+set auto_index(roiAreaResizeStart) [list source [file join $dir RoiAreaResize.wish]]
87+set auto_index(roiAreaResizeMotion) [list source [file join $dir RoiAreaResize.wish]]
88+set auto_index(roiAreaResizeEnd) [list source [file join $dir RoiAreaResize.wish]]
89+set auto_index(rectangleResize) [list source [file join $dir RoiAreaResize.wish]]
90+set auto_index(rectangleResizeCalc) [list source [file join $dir RoiAreaResize.wish]]
91+set auto_index(lineResize) [list source [file join $dir RoiAreaResize.wish]]
92+set auto_index(splineResize) [list source [file join $dir RoiAreaResize.wish]]
93+set auto_index(roiAreaRotateStart) [list source [file join $dir RoiAreaRotate.wish]]
94+set auto_index(roiAreaRotateMotion) [list source [file join $dir RoiAreaRotate.wish]]
95+set auto_index(roiAreaRotateEnd) [list source [file join $dir RoiAreaRotate.wish]]
96+set auto_index(rectangleRotate) [list source [file join $dir RoiAreaRotate.wish]]
97+set auto_index(rectangleRotateCalc) [list source [file join $dir RoiAreaRotate.wish]]
98+set auto_index(lineRotate) [list source [file join $dir RoiAreaRotate.wish]]
99+set auto_index(lineRotateCalc) [list source [file join $dir RoiAreaRotate.wish]]
100+set auto_index(splineRotate) [list source [file join $dir RoiAreaRotate.wish]]
101+set auto_index(splineRotateCalc) [list source [file join $dir RoiAreaRotate.wish]]
102+set auto_index(roiAreaSelectStart) [list source [file join $dir RoiAreaSelect.wish]]
103+set auto_index(roiAreaSelectMotion) [list source [file join $dir RoiAreaSelect.wish]]
104+set auto_index(roiAreaSelectEnd) [list source [file join $dir RoiAreaSelect.wish]]
105+set auto_index(roiAreaSelectOK) [list source [file join $dir RoiAreaSelect.wish]]
106+set auto_index(roiAreaFFT) [list source [file join $dir RoiAreaUtil.wish]]
107+set auto_index(splineNearPoint) [list source [file join $dir RoiAreaUtil.wish]]
108+set auto_index(rectangleNearPoint) [list source [file join $dir RoiAreaUtil.wish]]
109+set auto_index(lineNearPoint) [list source [file join $dir RoiAreaUtil.wish]]
110+set auto_index(pointDistance) [list source [file join $dir RoiAreaUtil.wish]]
111+set auto_index(pointDistance2) [list source [file join $dir RoiAreaUtil.wish]]
112+set auto_index(vectorAngle) [list source [file join $dir RoiAreaUtil.wish]]
113+set auto_index(coordGetInMainImageToReal) [list source [file join $dir RoiAreaUtil.wish]]
114+set auto_index(coordGetInMainImageToCanvas) [list source [file join $dir RoiAreaUtil.wish]]
115+set auto_index(dataGetInMainImageToReal) [list source [file join $dir RoiAreaUtil.wish]]
116+set auto_index(dataGetInMainImageToCanvas) [list source [file join $dir RoiAreaUtil.wish]]
117+set auto_index(pointSet) [list source [file join $dir RoiAreaUtil.wish]]
118+set auto_index(roiAreaZoomIn) [list source [file join $dir RoiAreaZoom.wish]]
119+set auto_index(roiAreaZoomOut) [list source [file join $dir RoiAreaZoom.wish]]
120+set auto_index(roiAreaZoom) [list source [file join $dir RoiAreaZoom.wish]]
121+set auto_index(ScaleRecreate) [list source [file join $dir ScaleUtil.wish]]
122+set auto_index(ScaleCreate) [list source [file join $dir ScaleUtil.wish]]
123+set auto_index(ScaleClear) [list source [file join $dir ScaleUtil.wish]]
124+set auto_index(ScaleChange) [list source [file join $dir ScaleUtil.wish]]
122125 set auto_index(sectionInit) [list source [file join $dir SectionUtil.wish]]
123126 set auto_index(sectionRecreateAll) [list source [file join $dir SectionUtil.wish]]
124127 set auto_index(sectionRecreate) [list source [file join $dir SectionUtil.wish]]
@@ -127,10 +130,5 @@ set auto_index(sectionCreate) [list source [file join $dir SectionUtil.wish]]
127130 set auto_index(sectionClearAll) [list source [file join $dir SectionUtil.wish]]
128131 set auto_index(sectionClear) [list source [file join $dir SectionUtil.wish]]
129132 set auto_index(sectionChange) [list source [file join $dir SectionUtil.wish]]
130-set auto_index(display2DesktopSet) [list source [file join $dir Display2Desktop.wish]]
131-set auto_index(display2ETCSet) [list source [file join $dir Display2ETCSet.wish]]
132-set auto_index(projectionRecreate) [list source [file join $dir ProjectionUtil.wish]]
133-set auto_index(projectionCreate) [list source [file join $dir ProjectionUtil.wish]]
134-set auto_index(projectionClear) [list source [file join $dir ProjectionUtil.wish]]
135-set auto_index(projectionChange) [list source [file join $dir ProjectionUtil.wish]]
136133 set auto_index(unitCellRecreate) [list source [file join $dir UnitCell.wish]]
134+set auto_index(fft2dCmd) [list source [file join $dir fft2dCmd.wish]]
Binary files a/hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageAutoCorrelationWithWindowing and b/hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageAutoCorrelationWithWindowing differ
Binary files a/hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageCTFCompensationForTiltImage and b/hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageCTFCompensationForTiltImage differ
Binary files a/hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageNormalizedSubtraction and b/hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageNormalizedSubtraction differ
Binary files a/hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageSpatialFrequencyFilter and b/hostdepend/X86LINUX64/bin/X86LINUX64/mrcImageSpatialFrequencyFilter differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libArray.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libArray.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libEosObjects.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libEosObjects.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libTclTk.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libTclTk.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libctfInfo.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libctfInfo.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libgifFile.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libgifFile.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libllData.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libllData.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libmrcImage.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libmrcImage.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libpdbFile.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libpdbFile.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/libtransform.a and b/hostdepend/X86LINUX64/lib/X86LINUX64/libtransform.a differ
Binary files a/hostdepend/X86LINUX64/lib/X86LINUX64/shared/lmrcImageSpatialFrequencyFilter.sharedo and b/hostdepend/X86LINUX64/lib/X86LINUX64/shared/lmrcImageSpatialFrequencyFilter.sharedo differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataExpress/TclTk/src/X86LINUX64/libTclTk.a and b/hostdepend/X86LINUX64/src/Objects/DataExpress/TclTk/src/X86LINUX64/libTclTk.a differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataExpress/gifFile/src/X86LINUX64/libgifFile.a and b/hostdepend/X86LINUX64/src/Objects/DataExpress/gifFile/src/X86LINUX64/libgifFile.a differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataManip/ctfInfo/src/X86LINUX64/libctfInfo.a and b/hostdepend/X86LINUX64/src/Objects/DataManip/ctfInfo/src/X86LINUX64/libctfInfo.a differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataManip/llData/src/X86LINUX64/libllData.a and b/hostdepend/X86LINUX64/src/Objects/DataManip/llData/src/X86LINUX64/libllData.a differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/libmrcImage.a and b/hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/libmrcImage.a differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/libmrcImage.debug.a and b/hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/libmrcImage.debug.a differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/lmrcImageSpatialFrequencyFilter.sharedo and b/hostdepend/X86LINUX64/src/Objects/DataManip/mrcImage/src/X86LINUX64/lmrcImageSpatialFrequencyFilter.sharedo differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataManip/pdbFile/src/X86LINUX64/libpdbFile.a and b/hostdepend/X86LINUX64/src/Objects/DataManip/pdbFile/src/X86LINUX64/libpdbFile.a differ
Binary files a/hostdepend/X86LINUX64/src/Objects/DataManip/transform/src/X86LINUX64/libtransform.a and b/hostdepend/X86LINUX64/src/Objects/DataManip/transform/src/X86LINUX64/libtransform.a differ
Binary files a/hostdepend/X86LINUX64/src/Objects/General/Array/src/X86LINUX64/libArray.a and b/hostdepend/X86LINUX64/src/Objects/General/Array/src/X86LINUX64/libArray.a differ
Binary files /dev/null and b/hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageAutoCorrelationWithWindowing/src/X86LINUX64/mrcImageAutoCorrelationWithWindowing differ
Binary files a/hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageCTFCompensationForTiltImage/src/X86LINUX64/mrcImageCTFCompensationForTiltImage and b/hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageCTFCompensationForTiltImage/src/X86LINUX64/mrcImageCTFCompensationForTiltImage differ
Binary files a/hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageNormalizedSubtraction/src/X86LINUX64/mrcImageNormalizedSubtraction and b/hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageNormalizedSubtraction/src/X86LINUX64/mrcImageNormalizedSubtraction differ
Binary files a/hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageSpatialFrequencyFilter/src/X86LINUX64/mrcImageSpatialFrequencyFilter and b/hostdepend/X86LINUX64/src/Tools/mrcImage/mrcImageSpatialFrequencyFilter/src/X86LINUX64/mrcImageSpatialFrequencyFilter differ
--- a/src/Objects/DataExpress/eosRuby/src/Swig/molvieRuby_wrap.c
+++ b/src/Objects/DataExpress/eosRuby/src/Swig/molvieRuby_wrap.c
@@ -0,0 +1,38909 @@
1+/* ----------------------------------------------------------------------------
2+ * This file was automatically generated by SWIG (http://www.swig.org).
3+ * Version 1.3.40
4+ *
5+ * This file is not intended to be easily readable and contains a number of
6+ * coding conventions designed to improve portability and efficiency. Do not make
7+ * changes to this file unless you know what you are doing--modify the SWIG
8+ * interface file instead.
9+ * ----------------------------------------------------------------------------- */
10+
11+#define SWIGRUBY
12+
13+/* -----------------------------------------------------------------------------
14+ * This section contains generic SWIG labels for method/variable
15+ * declarations/attributes, and other compiler dependent labels.
16+ * ----------------------------------------------------------------------------- */
17+
18+/* template workaround for compilers that cannot correctly implement the C++ standard */
19+#ifndef SWIGTEMPLATEDISAMBIGUATOR
20+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
21+# define SWIGTEMPLATEDISAMBIGUATOR template
22+# elif defined(__HP_aCC)
23+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
24+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
25+# define SWIGTEMPLATEDISAMBIGUATOR template
26+# else
27+# define SWIGTEMPLATEDISAMBIGUATOR
28+# endif
29+#endif
30+
31+/* inline attribute */
32+#ifndef SWIGINLINE
33+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
34+# define SWIGINLINE inline
35+# else
36+# define SWIGINLINE
37+# endif
38+#endif
39+
40+/* attribute recognised by some compilers to avoid 'unused' warnings */
41+#ifndef SWIGUNUSED
42+# if defined(__GNUC__)
43+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
44+# define SWIGUNUSED __attribute__ ((__unused__))
45+# else
46+# define SWIGUNUSED
47+# endif
48+# elif defined(__ICC)
49+# define SWIGUNUSED __attribute__ ((__unused__))
50+# else
51+# define SWIGUNUSED
52+# endif
53+#endif
54+
55+#ifndef SWIG_MSC_UNSUPPRESS_4505
56+# if defined(_MSC_VER)
57+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
58+# endif
59+#endif
60+
61+#ifndef SWIGUNUSEDPARM
62+# ifdef __cplusplus
63+# define SWIGUNUSEDPARM(p)
64+# else
65+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
66+# endif
67+#endif
68+
69+/* internal SWIG method */
70+#ifndef SWIGINTERN
71+# define SWIGINTERN static SWIGUNUSED
72+#endif
73+
74+/* internal inline SWIG method */
75+#ifndef SWIGINTERNINLINE
76+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
77+#endif
78+
79+/* exporting methods */
80+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
81+# ifndef GCC_HASCLASSVISIBILITY
82+# define GCC_HASCLASSVISIBILITY
83+# endif
84+#endif
85+
86+#ifndef SWIGEXPORT
87+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
88+# if defined(STATIC_LINKED)
89+# define SWIGEXPORT
90+# else
91+# define SWIGEXPORT __declspec(dllexport)
92+# endif
93+# else
94+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
95+# define SWIGEXPORT __attribute__ ((visibility("default")))
96+# else
97+# define SWIGEXPORT
98+# endif
99+# endif
100+#endif
101+
102+/* calling conventions for Windows */
103+#ifndef SWIGSTDCALL
104+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
105+# define SWIGSTDCALL __stdcall
106+# else
107+# define SWIGSTDCALL
108+# endif
109+#endif
110+
111+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
112+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
113+# define _CRT_SECURE_NO_DEPRECATE
114+#endif
115+
116+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
117+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
118+# define _SCL_SECURE_NO_DEPRECATE
119+#endif
120+
121+
122+/* -----------------------------------------------------------------------------
123+ * This section contains generic SWIG labels for method/variable
124+ * declarations/attributes, and other compiler dependent labels.
125+ * ----------------------------------------------------------------------------- */
126+
127+/* template workaround for compilers that cannot correctly implement the C++ standard */
128+#ifndef SWIGTEMPLATEDISAMBIGUATOR
129+# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
130+# define SWIGTEMPLATEDISAMBIGUATOR template
131+# elif defined(__HP_aCC)
132+/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
133+/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
134+# define SWIGTEMPLATEDISAMBIGUATOR template
135+# else
136+# define SWIGTEMPLATEDISAMBIGUATOR
137+# endif
138+#endif
139+
140+/* inline attribute */
141+#ifndef SWIGINLINE
142+# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
143+# define SWIGINLINE inline
144+# else
145+# define SWIGINLINE
146+# endif
147+#endif
148+
149+/* attribute recognised by some compilers to avoid 'unused' warnings */
150+#ifndef SWIGUNUSED
151+# if defined(__GNUC__)
152+# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
153+# define SWIGUNUSED __attribute__ ((__unused__))
154+# else
155+# define SWIGUNUSED
156+# endif
157+# elif defined(__ICC)
158+# define SWIGUNUSED __attribute__ ((__unused__))
159+# else
160+# define SWIGUNUSED
161+# endif
162+#endif
163+
164+#ifndef SWIG_MSC_UNSUPPRESS_4505
165+# if defined(_MSC_VER)
166+# pragma warning(disable : 4505) /* unreferenced local function has been removed */
167+# endif
168+#endif
169+
170+#ifndef SWIGUNUSEDPARM
171+# ifdef __cplusplus
172+# define SWIGUNUSEDPARM(p)
173+# else
174+# define SWIGUNUSEDPARM(p) p SWIGUNUSED
175+# endif
176+#endif
177+
178+/* internal SWIG method */
179+#ifndef SWIGINTERN
180+# define SWIGINTERN static SWIGUNUSED
181+#endif
182+
183+/* internal inline SWIG method */
184+#ifndef SWIGINTERNINLINE
185+# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
186+#endif
187+
188+/* exporting methods */
189+#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
190+# ifndef GCC_HASCLASSVISIBILITY
191+# define GCC_HASCLASSVISIBILITY
192+# endif
193+#endif
194+
195+#ifndef SWIGEXPORT
196+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
197+# if defined(STATIC_LINKED)
198+# define SWIGEXPORT
199+# else
200+# define SWIGEXPORT __declspec(dllexport)
201+# endif
202+# else
203+# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
204+# define SWIGEXPORT __attribute__ ((visibility("default")))
205+# else
206+# define SWIGEXPORT
207+# endif
208+# endif
209+#endif
210+
211+/* calling conventions for Windows */
212+#ifndef SWIGSTDCALL
213+# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
214+# define SWIGSTDCALL __stdcall
215+# else
216+# define SWIGSTDCALL
217+# endif
218+#endif
219+
220+/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
221+#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
222+# define _CRT_SECURE_NO_DEPRECATE
223+#endif
224+
225+/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
226+#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
227+# define _SCL_SECURE_NO_DEPRECATE
228+#endif
229+
230+
231+/* -----------------------------------------------------------------------------
232+ * swigrun.swg
233+ *
234+ * This file contains generic C API SWIG runtime support for pointer
235+ * type checking.
236+ * ----------------------------------------------------------------------------- */
237+
238+/* This should only be incremented when either the layout of swig_type_info changes,
239+ or for whatever reason, the runtime changes incompatibly */
240+#define SWIG_RUNTIME_VERSION "4"
241+
242+/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
243+#ifdef SWIG_TYPE_TABLE
244+# define SWIG_QUOTE_STRING(x) #x
245+# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
246+# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
247+#else
248+# define SWIG_TYPE_TABLE_NAME
249+#endif
250+
251+/*
252+ You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
253+ creating a static or dynamic library from the SWIG runtime code.
254+ In 99.9% of the cases, SWIG just needs to declare them as 'static'.
255+
256+ But only do this if strictly necessary, ie, if you have problems
257+ with your compiler or suchlike.
258+*/
259+
260+#ifndef SWIGRUNTIME
261+# define SWIGRUNTIME SWIGINTERN
262+#endif
263+
264+#ifndef SWIGRUNTIMEINLINE
265+# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
266+#endif
267+
268+/* Generic buffer size */
269+#ifndef SWIG_BUFFER_SIZE
270+# define SWIG_BUFFER_SIZE 1024
271+#endif
272+
273+/* Flags for pointer conversions */
274+#define SWIG_POINTER_DISOWN 0x1
275+#define SWIG_CAST_NEW_MEMORY 0x2
276+
277+/* Flags for new pointer objects */
278+#define SWIG_POINTER_OWN 0x1
279+
280+
281+/*
282+ Flags/methods for returning states.
283+
284+ The SWIG conversion methods, as ConvertPtr, return and integer
285+ that tells if the conversion was successful or not. And if not,
286+ an error code can be returned (see swigerrors.swg for the codes).
287+
288+ Use the following macros/flags to set or process the returning
289+ states.
290+
291+ In old versions of SWIG, code such as the following was usually written:
292+
293+ if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
294+ // success code
295+ } else {
296+ //fail code
297+ }
298+
299+ Now you can be more explicit:
300+
301+ int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
302+ if (SWIG_IsOK(res)) {
303+ // success code
304+ } else {
305+ // fail code
306+ }
307+
308+ which is the same really, but now you can also do
309+
310+ Type *ptr;
311+ int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
312+ if (SWIG_IsOK(res)) {
313+ // success code
314+ if (SWIG_IsNewObj(res) {
315+ ...
316+ delete *ptr;
317+ } else {
318+ ...
319+ }
320+ } else {
321+ // fail code
322+ }
323+
324+ I.e., now SWIG_ConvertPtr can return new objects and you can
325+ identify the case and take care of the deallocation. Of course that
326+ also requires SWIG_ConvertPtr to return new result values, such as
327+
328+ int SWIG_ConvertPtr(obj, ptr,...) {
329+ if (<obj is ok>) {
330+ if (<need new object>) {
331+ *ptr = <ptr to new allocated object>;
332+ return SWIG_NEWOBJ;
333+ } else {
334+ *ptr = <ptr to old object>;
335+ return SWIG_OLDOBJ;
336+ }
337+ } else {
338+ return SWIG_BADOBJ;
339+ }
340+ }
341+
342+ Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
343+ more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
344+ SWIG errors code.
345+
346+ Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
347+ allows to return the 'cast rank', for example, if you have this
348+
349+ int food(double)
350+ int fooi(int);
351+
352+ and you call
353+
354+ food(1) // cast rank '1' (1 -> 1.0)
355+ fooi(1) // cast rank '0'
356+
357+ just use the SWIG_AddCast()/SWIG_CheckState()
358+*/
359+
360+#define SWIG_OK (0)
361+#define SWIG_ERROR (-1)
362+#define SWIG_IsOK(r) (r >= 0)
363+#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
364+
365+/* The CastRankLimit says how many bits are used for the cast rank */
366+#define SWIG_CASTRANKLIMIT (1 << 8)
367+/* The NewMask denotes the object was created (using new/malloc) */
368+#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
369+/* The TmpMask is for in/out typemaps that use temporal objects */
370+#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
371+/* Simple returning values */
372+#define SWIG_BADOBJ (SWIG_ERROR)
373+#define SWIG_OLDOBJ (SWIG_OK)
374+#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
375+#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
376+/* Check, add and del mask methods */
377+#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
378+#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
379+#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
380+#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
381+#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
382+#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
383+
384+/* Cast-Rank Mode */
385+#if defined(SWIG_CASTRANK_MODE)
386+# ifndef SWIG_TypeRank
387+# define SWIG_TypeRank unsigned long
388+# endif
389+# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
390+# define SWIG_MAXCASTRANK (2)
391+# endif
392+# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
393+# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
394+SWIGINTERNINLINE int SWIG_AddCast(int r) {
395+ return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
396+}
397+SWIGINTERNINLINE int SWIG_CheckState(int r) {
398+ return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
399+}
400+#else /* no cast-rank mode */
401+# define SWIG_AddCast
402+# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
403+#endif
404+
405+
406+#include <string.h>
407+
408+#ifdef __cplusplus
409+extern "C" {
410+#endif
411+
412+typedef void *(*swig_converter_func)(void *, int *);
413+typedef struct swig_type_info *(*swig_dycast_func)(void **);
414+
415+/* Structure to store information on one type */
416+typedef struct swig_type_info {
417+ const char *name; /* mangled name of this type */
418+ const char *str; /* human readable name of this type */
419+ swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
420+ struct swig_cast_info *cast; /* linked list of types that can cast into this type */
421+ void *clientdata; /* language specific type data */
422+ int owndata; /* flag if the structure owns the clientdata */
423+} swig_type_info;
424+
425+/* Structure to store a type and conversion function used for casting */
426+typedef struct swig_cast_info {
427+ swig_type_info *type; /* pointer to type that is equivalent to this type */
428+ swig_converter_func converter; /* function to cast the void pointers */
429+ struct swig_cast_info *next; /* pointer to next cast in linked list */
430+ struct swig_cast_info *prev; /* pointer to the previous cast */
431+} swig_cast_info;
432+
433+/* Structure used to store module information
434+ * Each module generates one structure like this, and the runtime collects
435+ * all of these structures and stores them in a circularly linked list.*/
436+typedef struct swig_module_info {
437+ swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
438+ size_t size; /* Number of types in this module */
439+ struct swig_module_info *next; /* Pointer to next element in circularly linked list */
440+ swig_type_info **type_initial; /* Array of initially generated type structures */
441+ swig_cast_info **cast_initial; /* Array of initially generated casting structures */
442+ void *clientdata; /* Language specific module data */
443+} swig_module_info;
444+
445+/*
446+ Compare two type names skipping the space characters, therefore
447+ "char*" == "char *" and "Class<int>" == "Class<int >", etc.
448+
449+ Return 0 when the two name types are equivalent, as in
450+ strncmp, but skipping ' '.
451+*/
452+SWIGRUNTIME int
453+SWIG_TypeNameComp(const char *f1, const char *l1,
454+ const char *f2, const char *l2) {
455+ for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
456+ while ((*f1 == ' ') && (f1 != l1)) ++f1;
457+ while ((*f2 == ' ') && (f2 != l2)) ++f2;
458+ if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
459+ }
460+ return (int)((l1 - f1) - (l2 - f2));
461+}
462+
463+/*
464+ Check type equivalence in a name list like <name1>|<name2>|...
465+ Return 0 if not equal, 1 if equal
466+*/
467+SWIGRUNTIME int
468+SWIG_TypeEquiv(const char *nb, const char *tb) {
469+ int equiv = 0;
470+ const char* te = tb + strlen(tb);
471+ const char* ne = nb;
472+ while (!equiv && *ne) {
473+ for (nb = ne; *ne; ++ne) {
474+ if (*ne == '|') break;
475+ }
476+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
477+ if (*ne) ++ne;
478+ }
479+ return equiv;
480+}
481+
482+/*
483+ Check type equivalence in a name list like <name1>|<name2>|...
484+ Return 0 if equal, -1 if nb < tb, 1 if nb > tb
485+*/
486+SWIGRUNTIME int
487+SWIG_TypeCompare(const char *nb, const char *tb) {
488+ int equiv = 0;
489+ const char* te = tb + strlen(tb);
490+ const char* ne = nb;
491+ while (!equiv && *ne) {
492+ for (nb = ne; *ne; ++ne) {
493+ if (*ne == '|') break;
494+ }
495+ equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
496+ if (*ne) ++ne;
497+ }
498+ return equiv;
499+}
500+
501+
502+/*
503+ Check the typename
504+*/
505+SWIGRUNTIME swig_cast_info *
506+SWIG_TypeCheck(const char *c, swig_type_info *ty) {
507+ if (ty) {
508+ swig_cast_info *iter = ty->cast;
509+ while (iter) {
510+ if (strcmp(iter->type->name, c) == 0) {
511+ if (iter == ty->cast)
512+ return iter;
513+ /* Move iter to the top of the linked list */
514+ iter->prev->next = iter->next;
515+ if (iter->next)
516+ iter->next->prev = iter->prev;
517+ iter->next = ty->cast;
518+ iter->prev = 0;
519+ if (ty->cast) ty->cast->prev = iter;
520+ ty->cast = iter;
521+ return iter;
522+ }
523+ iter = iter->next;
524+ }
525+ }
526+ return 0;
527+}
528+
529+/*
530+ Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
531+*/
532+SWIGRUNTIME swig_cast_info *
533+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
534+ if (ty) {
535+ swig_cast_info *iter = ty->cast;
536+ while (iter) {
537+ if (iter->type == from) {
538+ if (iter == ty->cast)
539+ return iter;
540+ /* Move iter to the top of the linked list */
541+ iter->prev->next = iter->next;
542+ if (iter->next)
543+ iter->next->prev = iter->prev;
544+ iter->next = ty->cast;
545+ iter->prev = 0;
546+ if (ty->cast) ty->cast->prev = iter;
547+ ty->cast = iter;
548+ return iter;
549+ }
550+ iter = iter->next;
551+ }
552+ }
553+ return 0;
554+}
555+
556+/*
557+ Cast a pointer up an inheritance hierarchy
558+*/
559+SWIGRUNTIMEINLINE void *
560+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
561+ return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
562+}
563+
564+/*
565+ Dynamic pointer casting. Down an inheritance hierarchy
566+*/
567+SWIGRUNTIME swig_type_info *
568+SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
569+ swig_type_info *lastty = ty;
570+ if (!ty || !ty->dcast) return ty;
571+ while (ty && (ty->dcast)) {
572+ ty = (*ty->dcast)(ptr);
573+ if (ty) lastty = ty;
574+ }
575+ return lastty;
576+}
577+
578+/*
579+ Return the name associated with this type
580+*/
581+SWIGRUNTIMEINLINE const char *
582+SWIG_TypeName(const swig_type_info *ty) {
583+ return ty->name;
584+}
585+
586+/*
587+ Return the pretty name associated with this type,
588+ that is an unmangled type name in a form presentable to the user.
589+*/
590+SWIGRUNTIME const char *
591+SWIG_TypePrettyName(const swig_type_info *type) {
592+ /* The "str" field contains the equivalent pretty names of the
593+ type, separated by vertical-bar characters. We choose
594+ to print the last name, as it is often (?) the most
595+ specific. */
596+ if (!type) return NULL;
597+ if (type->str != NULL) {
598+ const char *last_name = type->str;
599+ const char *s;
600+ for (s = type->str; *s; s++)
601+ if (*s == '|') last_name = s+1;
602+ return last_name;
603+ }
604+ else
605+ return type->name;
606+}
607+
608+/*
609+ Set the clientdata field for a type
610+*/
611+SWIGRUNTIME void
612+SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
613+ swig_cast_info *cast = ti->cast;
614+ /* if (ti->clientdata == clientdata) return; */
615+ ti->clientdata = clientdata;
616+
617+ while (cast) {
618+ if (!cast->converter) {
619+ swig_type_info *tc = cast->type;
620+ if (!tc->clientdata) {
621+ SWIG_TypeClientData(tc, clientdata);
622+ }
623+ }
624+ cast = cast->next;
625+ }
626+}
627+SWIGRUNTIME void
628+SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
629+ SWIG_TypeClientData(ti, clientdata);
630+ ti->owndata = 1;
631+}
632+
633+/*
634+ Search for a swig_type_info structure only by mangled name
635+ Search is a O(log #types)
636+
637+ We start searching at module start, and finish searching when start == end.
638+ Note: if start == end at the beginning of the function, we go all the way around
639+ the circular list.
640+*/
641+SWIGRUNTIME swig_type_info *
642+SWIG_MangledTypeQueryModule(swig_module_info *start,
643+ swig_module_info *end,
644+ const char *name) {
645+ swig_module_info *iter = start;
646+ do {
647+ if (iter->size) {
648+ register size_t l = 0;
649+ register size_t r = iter->size - 1;
650+ do {
651+ /* since l+r >= 0, we can (>> 1) instead (/ 2) */
652+ register size_t i = (l + r) >> 1;
653+ const char *iname = iter->types[i]->name;
654+ if (iname) {
655+ register int compare = strcmp(name, iname);
656+ if (compare == 0) {
657+ return iter->types[i];
658+ } else if (compare < 0) {
659+ if (i) {
660+ r = i - 1;
661+ } else {
662+ break;
663+ }
664+ } else if (compare > 0) {
665+ l = i + 1;
666+ }
667+ } else {
668+ break; /* should never happen */
669+ }
670+ } while (l <= r);
671+ }
672+ iter = iter->next;
673+ } while (iter != end);
674+ return 0;
675+}
676+
677+/*
678+ Search for a swig_type_info structure for either a mangled name or a human readable name.
679+ It first searches the mangled names of the types, which is a O(log #types)
680+ If a type is not found it then searches the human readable names, which is O(#types).
681+
682+ We start searching at module start, and finish searching when start == end.
683+ Note: if start == end at the beginning of the function, we go all the way around
684+ the circular list.
685+*/
686+SWIGRUNTIME swig_type_info *
687+SWIG_TypeQueryModule(swig_module_info *start,
688+ swig_module_info *end,
689+ const char *name) {
690+ /* STEP 1: Search the name field using binary search */
691+ swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
692+ if (ret) {
693+ return ret;
694+ } else {
695+ /* STEP 2: If the type hasn't been found, do a complete search
696+ of the str field (the human readable name) */
697+ swig_module_info *iter = start;
698+ do {
699+ register size_t i = 0;
700+ for (; i < iter->size; ++i) {
701+ if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
702+ return iter->types[i];
703+ }
704+ iter = iter->next;
705+ } while (iter != end);
706+ }
707+
708+ /* neither found a match */
709+ return 0;
710+}
711+
712+/*
713+ Pack binary data into a string
714+*/
715+SWIGRUNTIME char *
716+SWIG_PackData(char *c, void *ptr, size_t sz) {
717+ static const char hex[17] = "0123456789abcdef";
718+ register const unsigned char *u = (unsigned char *) ptr;
719+ register const unsigned char *eu = u + sz;
720+ for (; u != eu; ++u) {
721+ register unsigned char uu = *u;
722+ *(c++) = hex[(uu & 0xf0) >> 4];
723+ *(c++) = hex[uu & 0xf];
724+ }
725+ return c;
726+}
727+
728+/*
729+ Unpack binary data from a string
730+*/
731+SWIGRUNTIME const char *
732+SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
733+ register unsigned char *u = (unsigned char *) ptr;
734+ register const unsigned char *eu = u + sz;
735+ for (; u != eu; ++u) {
736+ register char d = *(c++);
737+ register unsigned char uu;
738+ if ((d >= '0') && (d <= '9'))
739+ uu = ((d - '0') << 4);
740+ else if ((d >= 'a') && (d <= 'f'))
741+ uu = ((d - ('a'-10)) << 4);
742+ else
743+ return (char *) 0;
744+ d = *(c++);
745+ if ((d >= '0') && (d <= '9'))
746+ uu |= (d - '0');
747+ else if ((d >= 'a') && (d <= 'f'))
748+ uu |= (d - ('a'-10));
749+ else
750+ return (char *) 0;
751+ *u = uu;
752+ }
753+ return c;
754+}
755+
756+/*
757+ Pack 'void *' into a string buffer.
758+*/
759+SWIGRUNTIME char *
760+SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
761+ char *r = buff;
762+ if ((2*sizeof(void *) + 2) > bsz) return 0;
763+ *(r++) = '_';
764+ r = SWIG_PackData(r,&ptr,sizeof(void *));
765+ if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
766+ strcpy(r,name);
767+ return buff;
768+}
769+
770+SWIGRUNTIME const char *
771+SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
772+ if (*c != '_') {
773+ if (strcmp(c,"NULL") == 0) {
774+ *ptr = (void *) 0;
775+ return name;
776+ } else {
777+ return 0;
778+ }
779+ }
780+ return SWIG_UnpackData(++c,ptr,sizeof(void *));
781+}
782+
783+SWIGRUNTIME char *
784+SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
785+ char *r = buff;
786+ size_t lname = (name ? strlen(name) : 0);
787+ if ((2*sz + 2 + lname) > bsz) return 0;
788+ *(r++) = '_';
789+ r = SWIG_PackData(r,ptr,sz);
790+ if (lname) {
791+ strncpy(r,name,lname+1);
792+ } else {
793+ *r = 0;
794+ }
795+ return buff;
796+}
797+
798+SWIGRUNTIME const char *
799+SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
800+ if (*c != '_') {
801+ if (strcmp(c,"NULL") == 0) {
802+ memset(ptr,0,sz);
803+ return name;
804+ } else {
805+ return 0;
806+ }
807+ }
808+ return SWIG_UnpackData(++c,ptr,sz);
809+}
810+
811+#ifdef __cplusplus
812+}
813+#endif
814+
815+/* Errors in SWIG */
816+#define SWIG_UnknownError -1
817+#define SWIG_IOError -2
818+#define SWIG_RuntimeError -3
819+#define SWIG_IndexError -4
820+#define SWIG_TypeError -5
821+#define SWIG_DivisionByZero -6
822+#define SWIG_OverflowError -7
823+#define SWIG_SyntaxError -8
824+#define SWIG_ValueError -9
825+#define SWIG_SystemError -10
826+#define SWIG_AttributeError -11
827+#define SWIG_MemoryError -12
828+#define SWIG_NullReferenceError -13
829+
830+
831+
832+#include <ruby.h>
833+
834+/* Remove global macros defined in Ruby's win32.h */
835+#ifdef write
836+# undef write
837+#endif
838+#ifdef read
839+# undef read
840+#endif
841+#ifdef bind
842+# undef bind
843+#endif
844+#ifdef close
845+# undef close
846+#endif
847+#ifdef connect
848+# undef connect
849+#endif
850+
851+
852+/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
853+#ifndef NUM2LL
854+#define NUM2LL(x) NUM2LONG((x))
855+#endif
856+#ifndef LL2NUM
857+#define LL2NUM(x) INT2NUM((long) (x))
858+#endif
859+#ifndef ULL2NUM
860+#define ULL2NUM(x) UINT2NUM((unsigned long) (x))
861+#endif
862+
863+/* Ruby 1.7 doesn't (yet) define NUM2ULL() */
864+#ifndef NUM2ULL
865+#ifdef HAVE_LONG_LONG
866+#define NUM2ULL(x) rb_num2ull((x))
867+#else
868+#define NUM2ULL(x) NUM2ULONG(x)
869+#endif
870+#endif
871+
872+/* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
873+/* Define these for older versions so we can just write code the new way */
874+#ifndef RSTRING_LEN
875+# define RSTRING_LEN(x) RSTRING(x)->len
876+#endif
877+#ifndef RSTRING_PTR
878+# define RSTRING_PTR(x) RSTRING(x)->ptr
879+#endif
880+#ifndef RSTRING_END
881+# define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
882+#endif
883+#ifndef RARRAY_LEN
884+# define RARRAY_LEN(x) RARRAY(x)->len
885+#endif
886+#ifndef RARRAY_PTR
887+# define RARRAY_PTR(x) RARRAY(x)->ptr
888+#endif
889+#ifndef RFLOAT_VALUE
890+# define RFLOAT_VALUE(x) RFLOAT(x)->value
891+#endif
892+#ifndef DOUBLE2NUM
893+# define DOUBLE2NUM(x) rb_float_new(x)
894+#endif
895+#ifndef RHASH_TBL
896+# define RHASH_TBL(x) (RHASH(x)->tbl)
897+#endif
898+#ifndef RHASH_ITER_LEV
899+# define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
900+#endif
901+#ifndef RHASH_IFNONE
902+# define RHASH_IFNONE(x) (RHASH(x)->ifnone)
903+#endif
904+#ifndef RHASH_SIZE
905+# define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
906+#endif
907+#ifndef RHASH_EMPTY_P
908+# define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
909+#endif
910+#ifndef RSTRUCT_LEN
911+# define RSTRUCT_LEN(x) RSTRUCT(x)->len
912+#endif
913+#ifndef RSTRUCT_PTR
914+# define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
915+#endif
916+
917+
918+
919+/*
920+ * Need to be very careful about how these macros are defined, especially
921+ * when compiling C++ code or C code with an ANSI C compiler.
922+ *
923+ * VALUEFUNC(f) is a macro used to typecast a C function that implements
924+ * a Ruby method so that it can be passed as an argument to API functions
925+ * like rb_define_method() and rb_define_singleton_method().
926+ *
927+ * VOIDFUNC(f) is a macro used to typecast a C function that implements
928+ * either the "mark" or "free" stuff for a Ruby Data object, so that it
929+ * can be passed as an argument to API functions like Data_Wrap_Struct()
930+ * and Data_Make_Struct().
931+ */
932+
933+#ifdef __cplusplus
934+# ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
935+# define PROTECTFUNC(f) ((VALUE (*)()) f)
936+# define VALUEFUNC(f) ((VALUE (*)()) f)
937+# define VOIDFUNC(f) ((void (*)()) f)
938+# else
939+# ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
940+# define PROTECTFUNC(f) ((VALUE (*)()) f)
941+# define VALUEFUNC(f) ((VALUE (*)()) f)
942+# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
943+# else /* These definitions should work for Ruby 1.7+ */
944+# define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
945+# define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
946+# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
947+# endif
948+# endif
949+#else
950+# define VALUEFUNC(f) (f)
951+# define VOIDFUNC(f) (f)
952+#endif
953+
954+/* Don't use for expressions have side effect */
955+#ifndef RB_STRING_VALUE
956+#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
957+#endif
958+#ifndef StringValue
959+#define StringValue(s) RB_STRING_VALUE(s)
960+#endif
961+#ifndef StringValuePtr
962+#define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
963+#endif
964+#ifndef StringValueLen
965+#define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
966+#endif
967+#ifndef SafeStringValue
968+#define SafeStringValue(v) do {\
969+ StringValue(v);\
970+ rb_check_safe_str(v);\
971+} while (0)
972+#endif
973+
974+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
975+#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
976+#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
977+#endif
978+
979+static VALUE _mSWIG = Qnil;
980+
981+/* -----------------------------------------------------------------------------
982+ * error manipulation
983+ * ----------------------------------------------------------------------------- */
984+
985+
986+/* Define some additional error types */
987+#define SWIG_ObjectPreviouslyDeletedError -100
988+
989+
990+/* Define custom exceptions for errors that do not map to existing Ruby
991+ exceptions. Note this only works for C++ since a global cannot be
992+ initialized by a funtion in C. For C, fallback to rb_eRuntimeError.*/
993+
994+SWIGINTERN VALUE
995+getNullReferenceError(void) {
996+ static int init = 0;
997+ static VALUE rb_eNullReferenceError ;
998+ if (!init) {
999+ init = 1;
1000+ rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
1001+ }
1002+ return rb_eNullReferenceError;
1003+}
1004+
1005+SWIGINTERN VALUE
1006+getObjectPreviouslyDeletedError(void) {
1007+ static int init = 0;
1008+ static VALUE rb_eObjectPreviouslyDeleted ;
1009+ if (!init) {
1010+ init = 1;
1011+ rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
1012+ }
1013+ return rb_eObjectPreviouslyDeleted;
1014+}
1015+
1016+
1017+SWIGINTERN VALUE
1018+SWIG_Ruby_ErrorType(int SWIG_code) {
1019+ VALUE type;
1020+ switch (SWIG_code) {
1021+ case SWIG_MemoryError:
1022+ type = rb_eNoMemError;
1023+ break;
1024+ case SWIG_IOError:
1025+ type = rb_eIOError;
1026+ break;
1027+ case SWIG_RuntimeError:
1028+ type = rb_eRuntimeError;
1029+ break;
1030+ case SWIG_IndexError:
1031+ type = rb_eIndexError;
1032+ break;
1033+ case SWIG_TypeError:
1034+ type = rb_eTypeError;
1035+ break;
1036+ case SWIG_DivisionByZero:
1037+ type = rb_eZeroDivError;
1038+ break;
1039+ case SWIG_OverflowError:
1040+ type = rb_eRangeError;
1041+ break;
1042+ case SWIG_SyntaxError:
1043+ type = rb_eSyntaxError;
1044+ break;
1045+ case SWIG_ValueError:
1046+ type = rb_eArgError;
1047+ break;
1048+ case SWIG_SystemError:
1049+ type = rb_eFatal;
1050+ break;
1051+ case SWIG_AttributeError:
1052+ type = rb_eRuntimeError;
1053+ break;
1054+ case SWIG_NullReferenceError:
1055+ type = getNullReferenceError();
1056+ break;
1057+ case SWIG_ObjectPreviouslyDeletedError:
1058+ type = getObjectPreviouslyDeletedError();
1059+ break;
1060+ case SWIG_UnknownError:
1061+ type = rb_eRuntimeError;
1062+ break;
1063+ default:
1064+ type = rb_eRuntimeError;
1065+ }
1066+ return type;
1067+}
1068+
1069+
1070+/* This function is called when a user inputs a wrong argument to
1071+ a method.
1072+ */
1073+SWIGINTERN
1074+const char* Ruby_Format_TypeError( const char* msg,
1075+ const char* type,
1076+ const char* name,
1077+ const int argn,
1078+ VALUE input )
1079+{
1080+ char buf[128];
1081+ VALUE str;
1082+ VALUE asStr;
1083+ if ( msg && *msg )
1084+ {
1085+ str = rb_str_new2(msg);
1086+ }
1087+ else
1088+ {
1089+ str = rb_str_new(NULL, 0);
1090+ }
1091+
1092+ str = rb_str_cat2( str, "Expected argument " );
1093+ sprintf( buf, "%d of type ", argn-1 );
1094+ str = rb_str_cat2( str, buf );
1095+ str = rb_str_cat2( str, type );
1096+ str = rb_str_cat2( str, ", but got " );
1097+ str = rb_str_cat2( str, rb_obj_classname(input) );
1098+ str = rb_str_cat2( str, " " );
1099+ asStr = rb_inspect(input);
1100+ if ( RSTRING_LEN(asStr) > 30 )
1101+ {
1102+ str = rb_str_cat( str, StringValuePtr(asStr), 30 );
1103+ str = rb_str_cat2( str, "..." );
1104+ }
1105+ else
1106+ {
1107+ str = rb_str_append( str, asStr );
1108+ }
1109+
1110+ if ( name )
1111+ {
1112+ str = rb_str_cat2( str, "\n\tin SWIG method '" );
1113+ str = rb_str_cat2( str, name );
1114+ str = rb_str_cat2( str, "'" );
1115+ }
1116+
1117+ return StringValuePtr( str );
1118+}
1119+
1120+/* This function is called when an overloaded method fails */
1121+SWIGINTERN
1122+void Ruby_Format_OverloadedError(
1123+ const int argc,
1124+ const int maxargs,
1125+ const char* method,
1126+ const char* prototypes
1127+ )
1128+{
1129+ const char* msg = "Wrong # of arguments";
1130+ if ( argc <= maxargs ) msg = "Wrong arguments";
1131+ rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"
1132+ "Possible C/C++ prototypes are:\n%s",
1133+ msg, method, prototypes);
1134+}
1135+
1136+/* -----------------------------------------------------------------------------
1137+ * See the LICENSE file for information on copyright, usage and redistribution
1138+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1139+ *
1140+ * rubytracking.swg
1141+ *
1142+ * This file contains support for tracking mappings from
1143+ * Ruby objects to C++ objects. This functionality is needed
1144+ * to implement mark functions for Ruby's mark and sweep
1145+ * garbage collector.
1146+ * ----------------------------------------------------------------------------- */
1147+
1148+#ifdef __cplusplus
1149+extern "C" {
1150+#endif
1151+
1152+/* Ruby 1.8 actually assumes the first case. */
1153+#if SIZEOF_VOIDP == SIZEOF_LONG
1154+# define SWIG2NUM(v) LONG2NUM((unsigned long)v)
1155+# define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
1156+#elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
1157+# define SWIG2NUM(v) LL2NUM((unsigned long long)v)
1158+# define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
1159+#else
1160+# error sizeof(void*) is not the same as long or long long
1161+#endif
1162+
1163+
1164+/* Global Ruby hash table to store Trackings from C/C++
1165+ structs to Ruby Objects.
1166+*/
1167+static VALUE swig_ruby_trackings = Qnil;
1168+
1169+/* Global variable that stores a reference to the ruby
1170+ hash table delete function. */
1171+static ID swig_ruby_hash_delete;
1172+
1173+/* Setup a Ruby hash table to store Trackings */
1174+SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1175+ /* Create a ruby hash table to store Trackings from C++
1176+ objects to Ruby objects. */
1177+
1178+ /* Try to see if some other .so has already created a
1179+ tracking hash table, which we keep hidden in an instance var
1180+ in the SWIG module.
1181+ This is done to allow multiple DSOs to share the same
1182+ tracking table.
1183+ */
1184+ ID trackings_id = rb_intern( "@__trackings__" );
1185+ VALUE verbose = rb_gv_get("VERBOSE");
1186+ rb_gv_set("VERBOSE", Qfalse);
1187+ swig_ruby_trackings = rb_ivar_get( _mSWIG, trackings_id );
1188+ rb_gv_set("VERBOSE", verbose);
1189+
1190+ /* No, it hasn't. Create one ourselves */
1191+ if ( swig_ruby_trackings == Qnil )
1192+ {
1193+ swig_ruby_trackings = rb_hash_new();
1194+ rb_ivar_set( _mSWIG, trackings_id, swig_ruby_trackings );
1195+ }
1196+
1197+ /* Now store a reference to the hash table delete function
1198+ so that we only have to look it up once.*/
1199+ swig_ruby_hash_delete = rb_intern("delete");
1200+}
1201+
1202+/* Get a Ruby number to reference a pointer */
1203+SWIGRUNTIME VALUE SWIG_RubyPtrToReference(void* ptr) {
1204+ /* We cast the pointer to an unsigned long
1205+ and then store a reference to it using
1206+ a Ruby number object. */
1207+
1208+ /* Convert the pointer to a Ruby number */
1209+ return SWIG2NUM(ptr);
1210+}
1211+
1212+/* Get a Ruby number to reference an object */
1213+SWIGRUNTIME VALUE SWIG_RubyObjectToReference(VALUE object) {
1214+ /* We cast the object to an unsigned long
1215+ and then store a reference to it using
1216+ a Ruby number object. */
1217+
1218+ /* Convert the Object to a Ruby number */
1219+ return SWIG2NUM(object);
1220+}
1221+
1222+/* Get a Ruby object from a previously stored reference */
1223+SWIGRUNTIME VALUE SWIG_RubyReferenceToObject(VALUE reference) {
1224+ /* The provided Ruby number object is a reference
1225+ to the Ruby object we want.*/
1226+
1227+ /* Convert the Ruby number to a Ruby object */
1228+ return NUM2SWIG(reference);
1229+}
1230+
1231+/* Add a Tracking from a C/C++ struct to a Ruby object */
1232+SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
1233+ /* In a Ruby hash table we store the pointer and
1234+ the associated Ruby object. The trick here is
1235+ that we cannot store the Ruby object directly - if
1236+ we do then it cannot be garbage collected. So
1237+ instead we typecast it as a unsigned long and
1238+ convert it to a Ruby number object.*/
1239+
1240+ /* Get a reference to the pointer as a Ruby number */
1241+ VALUE key = SWIG_RubyPtrToReference(ptr);
1242+
1243+ /* Get a reference to the Ruby object as a Ruby number */
1244+ VALUE value = SWIG_RubyObjectToReference(object);
1245+
1246+ /* Store the mapping to the global hash table. */
1247+ rb_hash_aset(swig_ruby_trackings, key, value);
1248+}
1249+
1250+/* Get the Ruby object that owns the specified C/C++ struct */
1251+SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1252+ /* Get a reference to the pointer as a Ruby number */
1253+ VALUE key = SWIG_RubyPtrToReference(ptr);
1254+
1255+ /* Now lookup the value stored in the global hash table */
1256+ VALUE value = rb_hash_aref(swig_ruby_trackings, key);
1257+
1258+ if (value == Qnil) {
1259+ /* No object exists - return nil. */
1260+ return Qnil;
1261+ }
1262+ else {
1263+ /* Convert this value to Ruby object */
1264+ return SWIG_RubyReferenceToObject(value);
1265+ }
1266+}
1267+
1268+/* Remove a Tracking from a C/C++ struct to a Ruby object. It
1269+ is very important to remove objects once they are destroyed
1270+ since the same memory address may be reused later to create
1271+ a new object. */
1272+SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
1273+ /* Get a reference to the pointer as a Ruby number */
1274+ VALUE key = SWIG_RubyPtrToReference(ptr);
1275+
1276+ /* Delete the object from the hash table by calling Ruby's
1277+ do this we need to call the Hash.delete method.*/
1278+ rb_funcall(swig_ruby_trackings, swig_ruby_hash_delete, 1, key);
1279+}
1280+
1281+/* This is a helper method that unlinks a Ruby object from its
1282+ underlying C++ object. This is needed if the lifetime of the
1283+ Ruby object is longer than the C++ object */
1284+SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
1285+ VALUE object = SWIG_RubyInstanceFor(ptr);
1286+
1287+ if (object != Qnil) {
1288+ DATA_PTR(object) = 0;
1289+ }
1290+}
1291+
1292+
1293+#ifdef __cplusplus
1294+}
1295+#endif
1296+
1297+/* -----------------------------------------------------------------------------
1298+ * Ruby API portion that goes into the runtime
1299+ * ----------------------------------------------------------------------------- */
1300+
1301+#ifdef __cplusplus
1302+extern "C" {
1303+#endif
1304+
1305+SWIGINTERN VALUE
1306+SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1307+ if (NIL_P(target)) {
1308+ target = o;
1309+ } else {
1310+ if (TYPE(target) != T_ARRAY) {
1311+ VALUE o2 = target;
1312+ target = rb_ary_new();
1313+ rb_ary_push(target, o2);
1314+ }
1315+ rb_ary_push(target, o);
1316+ }
1317+ return target;
1318+}
1319+
1320+/* For ruby1.8.4 and earlier. */
1321+#ifndef RUBY_INIT_STACK
1322+ RUBY_EXTERN void Init_stack(VALUE* addr);
1323+# define RUBY_INIT_STACK \
1324+ VALUE variable_in_this_stack_frame; \
1325+ Init_stack(&variable_in_this_stack_frame);
1326+#endif
1327+
1328+
1329+#ifdef __cplusplus
1330+}
1331+#endif
1332+
1333+
1334+/* -----------------------------------------------------------------------------
1335+ * See the LICENSE file for information on copyright, usage and redistribution
1336+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
1337+ *
1338+ * rubyrun.swg
1339+ *
1340+ * This file contains the runtime support for Ruby modules
1341+ * and includes code for managing global variables and pointer
1342+ * type checking.
1343+ * ----------------------------------------------------------------------------- */
1344+
1345+/* For backward compatibility only */
1346+#define SWIG_POINTER_EXCEPTION 0
1347+
1348+/* for raw pointers */
1349+#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1350+#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1351+#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
1352+#define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
1353+#define swig_owntype ruby_owntype
1354+
1355+/* for raw packed data */
1356+#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
1357+#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1358+
1359+/* for class or struct pointers */
1360+#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1361+#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1362+
1363+/* for C or C++ function pointers */
1364+#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
1365+#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
1366+
1367+/* for C++ member pointers, ie, member methods */
1368+#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
1369+#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1370+
1371+
1372+/* Runtime API */
1373+
1374+#define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule()
1375+#define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)
1376+
1377+
1378+/* Error manipulation */
1379+
1380+#define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
1381+#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg)
1382+#define SWIG_fail goto fail
1383+
1384+
1385+/* Ruby-specific SWIG API */
1386+
1387+#define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()
1388+#define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)
1389+#define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty)
1390+#define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)
1391+#define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)
1392+
1393+#include "assert.h"
1394+
1395+/* -----------------------------------------------------------------------------
1396+ * pointers/data manipulation
1397+ * ----------------------------------------------------------------------------- */
1398+
1399+#ifdef __cplusplus
1400+extern "C" {
1401+#endif
1402+
1403+typedef struct {
1404+ VALUE klass;
1405+ VALUE mImpl;
1406+ void (*mark)(void *);
1407+ void (*destroy)(void *);
1408+ int trackObjects;
1409+} swig_class;
1410+
1411+
1412+/* Global pointer used to keep some internal SWIG stuff */
1413+static VALUE _cSWIG_Pointer = Qnil;
1414+static VALUE swig_runtime_data_type_pointer = Qnil;
1415+
1416+/* Global IDs used to keep some internal SWIG stuff */
1417+static ID swig_arity_id = 0;
1418+static ID swig_call_id = 0;
1419+
1420+/*
1421+ If your swig extension is to be run within an embedded ruby and has
1422+ director callbacks, you should set -DRUBY_EMBEDDED during compilation.
1423+ This will reset ruby's stack frame on each entry point from the main
1424+ program the first time a virtual director function is invoked (in a
1425+ non-recursive way).
1426+ If this is not done, you run the risk of Ruby trashing the stack.
1427+*/
1428+
1429+#ifdef RUBY_EMBEDDED
1430+
1431+# define SWIG_INIT_STACK \
1432+ if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
1433+ ++swig_virtual_calls;
1434+# define SWIG_RELEASE_STACK --swig_virtual_calls;
1435+# define Ruby_DirectorTypeMismatchException(x) \
1436+ rb_raise( rb_eTypeError, x ); return c_result;
1437+
1438+ static unsigned int swig_virtual_calls = 0;
1439+
1440+#else /* normal non-embedded extension */
1441+
1442+# define SWIG_INIT_STACK
1443+# define SWIG_RELEASE_STACK
1444+# define Ruby_DirectorTypeMismatchException(x) \
1445+ throw Swig::DirectorTypeMismatchException( x );
1446+
1447+#endif /* RUBY_EMBEDDED */
1448+
1449+
1450+SWIGRUNTIME VALUE
1451+getExceptionClass(void) {
1452+ static int init = 0;
1453+ static VALUE rubyExceptionClass ;
1454+ if (!init) {
1455+ init = 1;
1456+ rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
1457+ }
1458+ return rubyExceptionClass;
1459+}
1460+
1461+/* This code checks to see if the Ruby object being raised as part
1462+ of an exception inherits from the Ruby class Exception. If so,
1463+ the object is simply returned. If not, then a new Ruby exception
1464+ object is created and that will be returned to Ruby.*/
1465+SWIGRUNTIME VALUE
1466+SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
1467+ VALUE exceptionClass = getExceptionClass();
1468+ if (rb_obj_is_kind_of(obj, exceptionClass)) {
1469+ return obj;
1470+ } else {
1471+ return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
1472+ }
1473+}
1474+
1475+/* Initialize Ruby runtime support */
1476+SWIGRUNTIME void
1477+SWIG_Ruby_InitRuntime(void)
1478+{
1479+ if (_mSWIG == Qnil) {
1480+ _mSWIG = rb_define_module("SWIG");
1481+ swig_call_id = rb_intern("call");
1482+ swig_arity_id = rb_intern("arity");
1483+ }
1484+}
1485+
1486+/* Define Ruby class for C type */
1487+SWIGRUNTIME void
1488+SWIG_Ruby_define_class(swig_type_info *type)
1489+{
1490+ VALUE klass;
1491+ char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1492+ sprintf(klass_name, "TYPE%s", type->name);
1493+ if (NIL_P(_cSWIG_Pointer)) {
1494+ _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
1495+ rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
1496+ }
1497+ klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1498+ free((void *) klass_name);
1499+}
1500+
1501+/* Create a new pointer object */
1502+SWIGRUNTIME VALUE
1503+SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1504+{
1505+ int own = flags & SWIG_POINTER_OWN;
1506+ int track;
1507+ char *klass_name;
1508+ swig_class *sklass;
1509+ VALUE klass;
1510+ VALUE obj;
1511+
1512+ if (!ptr)
1513+ return Qnil;
1514+
1515+ if (type->clientdata) {
1516+ sklass = (swig_class *) type->clientdata;
1517+
1518+ /* Are we tracking this class and have we already returned this Ruby object? */
1519+ track = sklass->trackObjects;
1520+ if (track) {
1521+ obj = SWIG_RubyInstanceFor(ptr);
1522+
1523+ /* Check the object's type and make sure it has the correct type.
1524+ It might not in cases where methods do things like
1525+ downcast methods. */
1526+ if (obj != Qnil) {
1527+ VALUE value = rb_iv_get(obj, "@__swigtype__");
1528+ char* type_name = RSTRING_PTR(value);
1529+
1530+ if (strcmp(type->name, type_name) == 0) {
1531+ return obj;
1532+ }
1533+ }
1534+ }
1535+
1536+ /* Create a new Ruby object */
1537+ obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),
1538+ ( own ? VOIDFUNC(sklass->destroy) :
1539+ (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
1540+ ), ptr);
1541+
1542+ /* If tracking is on for this class then track this object. */
1543+ if (track) {
1544+ SWIG_RubyAddTracking(ptr, obj);
1545+ }
1546+ } else {
1547+ klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1548+ sprintf(klass_name, "TYPE%s", type->name);
1549+ klass = rb_const_get(_mSWIG, rb_intern(klass_name));
1550+ free((void *) klass_name);
1551+ obj = Data_Wrap_Struct(klass, 0, 0, ptr);
1552+ }
1553+ rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1554+
1555+ return obj;
1556+}
1557+
1558+/* Create a new class instance (always owned) */
1559+SWIGRUNTIME VALUE
1560+SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1561+{
1562+ VALUE obj;
1563+ swig_class *sklass = (swig_class *) type->clientdata;
1564+ obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
1565+ rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1566+ return obj;
1567+}
1568+
1569+/* Get type mangle from class name */
1570+SWIGRUNTIMEINLINE char *
1571+SWIG_Ruby_MangleStr(VALUE obj)
1572+{
1573+ VALUE stype = rb_iv_get(obj, "@__swigtype__");
1574+ return StringValuePtr(stype);
1575+}
1576+
1577+/* Acquire a pointer value */
1578+typedef void (*ruby_owntype)(void*);
1579+
1580+SWIGRUNTIME ruby_owntype
1581+SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
1582+ if (obj) {
1583+ ruby_owntype oldown = RDATA(obj)->dfree;
1584+ RDATA(obj)->dfree = own;
1585+ return oldown;
1586+ } else {
1587+ return 0;
1588+ }
1589+}
1590+
1591+/* Convert a pointer value */
1592+SWIGRUNTIME int
1593+SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
1594+{
1595+ char *c;
1596+ swig_cast_info *tc;
1597+ void *vptr = 0;
1598+
1599+ /* Grab the pointer */
1600+ if (NIL_P(obj)) {
1601+ *ptr = 0;
1602+ return SWIG_OK;
1603+ } else {
1604+ if (TYPE(obj) != T_DATA) {
1605+ return SWIG_ERROR;
1606+ }
1607+ Data_Get_Struct(obj, void, vptr);
1608+ }
1609+
1610+ if (own) *own = RDATA(obj)->dfree;
1611+
1612+ /* Check to see if the input object is giving up ownership
1613+ of the underlying C struct or C++ object. If so then we
1614+ need to reset the destructor since the Ruby object no
1615+ longer owns the underlying C++ object.*/
1616+ if (flags & SWIG_POINTER_DISOWN) {
1617+ /* Is tracking on for this class? */
1618+ int track = 0;
1619+ if (ty && ty->clientdata) {
1620+ swig_class *sklass = (swig_class *) ty->clientdata;
1621+ track = sklass->trackObjects;
1622+ }
1623+
1624+ if (track) {
1625+ /* We are tracking objects for this class. Thus we change the destructor
1626+ * to SWIG_RubyRemoveTracking. This allows us to
1627+ * remove the mapping from the C++ to Ruby object
1628+ * when the Ruby object is garbage collected. If we don't
1629+ * do this, then it is possible we will return a reference
1630+ * to a Ruby object that no longer exists thereby crashing Ruby. */
1631+ RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
1632+ } else {
1633+ RDATA(obj)->dfree = 0;
1634+ }
1635+ }
1636+
1637+ /* Do type-checking if type info was provided */
1638+ if (ty) {
1639+ if (ty->clientdata) {
1640+ if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
1641+ if (vptr == 0) {
1642+ /* The object has already been deleted */
1643+ return SWIG_ObjectPreviouslyDeletedError;
1644+ }
1645+ *ptr = vptr;
1646+ return SWIG_OK;
1647+ }
1648+ }
1649+ if ((c = SWIG_MangleStr(obj)) == NULL) {
1650+ return SWIG_ERROR;
1651+ }
1652+ tc = SWIG_TypeCheck(c, ty);
1653+ if (!tc) {
1654+ return SWIG_ERROR;
1655+ } else {
1656+ int newmemory = 0;
1657+ *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
1658+ assert(!newmemory); /* newmemory handling not yet implemented */
1659+ }
1660+ } else {
1661+ *ptr = vptr;
1662+ }
1663+
1664+ return SWIG_OK;
1665+}
1666+
1667+/* Check convert */
1668+SWIGRUNTIMEINLINE int
1669+SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
1670+{
1671+ char *c = SWIG_MangleStr(obj);
1672+ if (!c) return 0;
1673+ return SWIG_TypeCheck(c,ty) != 0;
1674+}
1675+
1676+SWIGRUNTIME VALUE
1677+SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1678+ char result[1024];
1679+ char *r = result;
1680+ if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1681+ *(r++) = '_';
1682+ r = SWIG_PackData(r, ptr, sz);
1683+ strcpy(r, type->name);
1684+ return rb_str_new2(result);
1685+}
1686+
1687+/* Convert a packed value value */
1688+SWIGRUNTIME int
1689+SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
1690+ swig_cast_info *tc;
1691+ const char *c;
1692+
1693+ if (TYPE(obj) != T_STRING) goto type_error;
1694+ c = StringValuePtr(obj);
1695+ /* Pointer values must start with leading underscore */
1696+ if (*c != '_') goto type_error;
1697+ c++;
1698+ c = SWIG_UnpackData(c, ptr, sz);
1699+ if (ty) {
1700+ tc = SWIG_TypeCheck(c, ty);
1701+ if (!tc) goto type_error;
1702+ }
1703+ return SWIG_OK;
1704+
1705+ type_error:
1706+ return SWIG_ERROR;
1707+}
1708+
1709+SWIGRUNTIME swig_module_info *
1710+SWIG_Ruby_GetModule(void)
1711+{
1712+ VALUE pointer;
1713+ swig_module_info *ret = 0;
1714+ VALUE verbose = rb_gv_get("VERBOSE");
1715+
1716+ /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
1717+ rb_gv_set("VERBOSE", Qfalse);
1718+
1719+ /* first check if pointer already created */
1720+ pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1721+ if (pointer != Qnil) {
1722+ Data_Get_Struct(pointer, swig_module_info, ret);
1723+ }
1724+
1725+ /* reinstate warnings */
1726+ rb_gv_set("VERBOSE", verbose);
1727+ return ret;
1728+}
1729+
1730+SWIGRUNTIME void
1731+SWIG_Ruby_SetModule(swig_module_info *pointer)
1732+{
1733+ /* register a new class */
1734+ VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
1735+ /* create and store the structure pointer to a global variable */
1736+ swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
1737+ rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
1738+}
1739+
1740+/* This function can be used to check whether a proc or method or similarly
1741+ callable function has been passed. Usually used in a %typecheck, like:
1742+
1743+ %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
1744+ $result = SWIG_Ruby_isCallable( $input );
1745+ }
1746+ */
1747+SWIGINTERN
1748+int SWIG_Ruby_isCallable( VALUE proc )
1749+{
1750+ if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
1751+ return 1;
1752+ return 0;
1753+}
1754+
1755+/* This function can be used to check the arity (number of arguments)
1756+ a proc or method can take. Usually used in a %typecheck.
1757+ Valid arities will be that equal to minimal or those < 0
1758+ which indicate a variable number of parameters at the end.
1759+ */
1760+SWIGINTERN
1761+int SWIG_Ruby_arity( VALUE proc, int minimal )
1762+{
1763+ if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
1764+ {
1765+ VALUE num = rb_funcall( proc, swig_arity_id, 0 );
1766+ int arity = NUM2INT(num);
1767+ if ( arity < 0 && (arity+1) < -minimal ) return 1;
1768+ if ( arity == minimal ) return 1;
1769+ return 1;
1770+ }
1771+ return 0;
1772+}
1773+
1774+
1775+#ifdef __cplusplus
1776+}
1777+#endif
1778+
1779+
1780+
1781+#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1782+
1783+#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1784+
1785+
1786+
1787+/* -------- TYPES TABLE (BEGIN) -------- */
1788+
1789+#define SWIGTYPE_p_Array swig_types[0]
1790+#define SWIGTYPE_p_Coord swig_types[1]
1791+#define SWIGTYPE_p_EulerAngleInfo swig_types[2]
1792+#define SWIGTYPE_p_FEIextendedHeader swig_types[3]
1793+#define SWIGTYPE_p_FILE swig_types[4]
1794+#define SWIGTYPE_p_GLboolean swig_types[5]
1795+#define SWIGTYPE_p_GLdouble swig_types[6]
1796+#define SWIGTYPE_p_GLfloat swig_types[7]
1797+#define SWIGTYPE_p_GLint swig_types[8]
1798+#define SWIGTYPE_p_GLuint swig_types[9]
1799+#define SWIGTYPE_p_MRC_Status_t swig_types[10]
1800+#define SWIGTYPE_p_MRC_Status_t_status swig_types[11]
1801+#define SWIGTYPE_p_ProteinStatus swig_types[12]
1802+#define SWIGTYPE_p_Quat swig_types[13]
1803+#define SWIGTYPE_p__FEIextendedHeader swig_types[14]
1804+#define SWIGTYPE_p__mrcImageHeader swig_types[15]
1805+#define SWIGTYPE_p__mrcImageHeaderCCP4 swig_types[16]
1806+#define SWIGTYPE_p__mrcImageHeaderIMOD swig_types[17]
1807+#define SWIGTYPE_p__mrcImageTailer swig_types[18]
1808+#define SWIGTYPE_p_a_4__a_4__float swig_types[19]
1809+#define SWIGTYPE_p_a_4__float swig_types[20]
1810+#define SWIGTYPE_p_a__80___char swig_types[21]
1811+#define SWIGTYPE_p_cameraInfo swig_types[22]
1812+#define SWIGTYPE_p_char swig_types[23]
1813+#define SWIGTYPE_p_contourLinesSet swig_types[24]
1814+#define SWIGTYPE_p_ctfInfo swig_types[25]
1815+#define SWIGTYPE_p_displayMode swig_types[26]
1816+#define SWIGTYPE_p_double swig_types[27]
1817+#define SWIGTYPE_p_elementSwitch swig_types[28]
1818+#define SWIGTYPE_p_float swig_types[29]
1819+#define SWIGTYPE_p_floatVector swig_types[30]
1820+#define SWIGTYPE_p_int swig_types[31]
1821+#define SWIGTYPE_p_lmrcImageBandPassFilterInfo swig_types[32]
1822+#define SWIGTYPE_p_lmrcImageCTFSNInfo swig_types[33]
1823+#define SWIGTYPE_p_lmrcImageCVEInfo swig_types[34]
1824+#define SWIGTYPE_p_lmrcImageFourierPowerSpectrumInfo swig_types[35]
1825+#define SWIGTYPE_p_lmrcImageHighPassFilterInfo swig_types[36]
1826+#define SWIGTYPE_p_lmrcImageHighlightInfo swig_types[37]
1827+#define SWIGTYPE_p_lmrcImageLowPassFilterInfo swig_types[38]
1828+#define SWIGTYPE_p_lmrcImageMultiCTFCompensationInfo swig_types[39]
1829+#define SWIGTYPE_p_lmrcImageMultiCTFCompensationSolventFlatteningMode swig_types[40]
1830+#define SWIGTYPE_p_lmrcImageSmoothingInfo swig_types[41]
1831+#define SWIGTYPE_p_lmrcImageTfunctionInfo swig_types[42]
1832+#define SWIGTYPE_p_long swig_types[43]
1833+#define SWIGTYPE_p_molvieInfo swig_types[44]
1834+#define SWIGTYPE_p_mrcImage swig_types[45]
1835+#define SWIGTYPE_p_mrcImageDataSetMode swig_types[46]
1836+#define SWIGTYPE_p_mrcImageFourierPowerSpectrum swig_types[47]
1837+#define SWIGTYPE_p_mrcImageHeader swig_types[48]
1838+#define SWIGTYPE_p_mrcImageInformation swig_types[49]
1839+#define SWIGTYPE_p_mrcImageInformationMode swig_types[50]
1840+#define SWIGTYPE_p_mrcImageParaTypeIntegerCoord swig_types[51]
1841+#define SWIGTYPE_p_mrcImageParaTypeRealCoord swig_types[52]
1842+#define SWIGTYPE_p_mrcImageTailer swig_types[53]
1843+#define SWIGTYPE_p_mrcPixelDataHowToGet swig_types[54]
1844+#define SWIGTYPE_p_mrcPixelDataType swig_types[55]
1845+#define SWIGTYPE_p_operationMode swig_types[56]
1846+#define SWIGTYPE_p_p_char swig_types[57]
1847+#define SWIGTYPE_p_p_double swig_types[58]
1848+#define SWIGTYPE_p_p_floatVector swig_types[59]
1849+#define SWIGTYPE_p_pdbCenter swig_types[60]
1850+#define SWIGTYPE_p_pdbCoord swig_types[61]
1851+#define SWIGTYPE_p_pdbFile swig_types[62]
1852+#define SWIGTYPE_p_pdbFileSecondaryStructure swig_types[63]
1853+#define SWIGTYPE_p_pdbFileSecondaryStructureMode swig_types[64]
1854+#define SWIGTYPE_p_pdbFileSecondaryStructureRecord swig_types[65]
1855+#define SWIGTYPE_p_pdbRecord swig_types[66]
1856+#define SWIGTYPE_p_pdbSecondaryStructureHelix swig_types[67]
1857+#define SWIGTYPE_p_pdbSecondaryStructureHelixClass swig_types[68]
1858+#define SWIGTYPE_p_pdbSecondaryStructureNo swig_types[69]
1859+#define SWIGTYPE_p_pdbSecondaryStructureSheet swig_types[70]
1860+#define SWIGTYPE_p_pdbSecondaryStructureTurn swig_types[71]
1861+#define SWIGTYPE_p_residueName swig_types[72]
1862+#define SWIGTYPE_p_short swig_types[73]
1863+#define SWIGTYPE_p_unsigned_char swig_types[74]
1864+#define SWIGTYPE_p_unsigned_int swig_types[75]
1865+#define SWIGTYPE_p_unsigned_long swig_types[76]
1866+#define SWIGTYPE_p_unsigned_short swig_types[77]
1867+static swig_type_info *swig_types[79];
1868+static swig_module_info swig_module = {swig_types, 78, 0, 0, 0, 0};
1869+#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1870+#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1871+
1872+/* -------- TYPES TABLE (END) -------- */
1873+
1874+#define SWIG_init Init_molvieRuby
1875+#define SWIG_name "MolvieRuby"
1876+
1877+static VALUE mMolvieRuby;
1878+
1879+#define SWIG_RUBY_THREAD_BEGIN_BLOCK
1880+#define SWIG_RUBY_THREAD_END_BLOCK
1881+
1882+
1883+#define SWIGVERSION 0x010340
1884+#define SWIG_VERSION SWIGVERSION
1885+
1886+
1887+#define SWIG_as_voidptr(a) (void *)((const void *)(a))
1888+#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1889+
1890+
1891+#include <ruby.h>
1892+#include <stdio.h>
1893+#include <stdlib.h>
1894+#include <math.h>
1895+#include <GL/glut.h>
1896+
1897+#include "Matrix3D.h"
1898+#include "mrcImage.h"
1899+#include "pdbFile.h"
1900+#include "DisplayListNumber.h"
1901+#include "lmolvieProteinStatus.h"
1902+#include "molvieDefault.h"
1903+#include "molvieDockDefault.h"
1904+#include "molvieFlightDefault.h"
1905+#include "molvieMrcViewerDefault.h"
1906+#include "molvieProjectionDefault.h"
1907+#include "molvieViewerDefault.h"
1908+#include "lmolvie.h"
1909+
1910+
1911+
1912+#include <limits.h>
1913+#if !defined(SWIG_NO_LLONG_MAX)
1914+# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1915+# define LLONG_MAX __LONG_LONG_MAX__
1916+# define LLONG_MIN (-LLONG_MAX - 1LL)
1917+# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1918+# endif
1919+#endif
1920+
1921+
1922+ #define SWIG_From_long LONG2NUM
1923+
1924+
1925+SWIGINTERNINLINE VALUE
1926+SWIG_From_int (int value)
1927+{
1928+ return SWIG_From_long (value);
1929+}
1930+
1931+
1932+ #define SWIG_From_double rb_float_new
1933+
1934+
1935+SWIGINTERN swig_type_info*
1936+SWIG_pchar_descriptor(void)
1937+{
1938+ static int init = 0;
1939+ static swig_type_info* info = 0;
1940+ if (!init) {
1941+ info = SWIG_TypeQuery("_p_char");
1942+ init = 1;
1943+ }
1944+ return info;
1945+}
1946+
1947+
1948+SWIGINTERN int
1949+SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
1950+{
1951+ if (TYPE(obj) == T_STRING) {
1952+ #if defined(StringValuePtr)
1953+ char *cstr = StringValuePtr(obj);
1954+ #else
1955+ char *cstr = STR2CSTR(obj);
1956+ #endif
1957+ size_t size = RSTRING_LEN(obj) + 1;
1958+ if (cptr) {
1959+ if (alloc) {
1960+ if (*alloc == SWIG_NEWOBJ) {
1961+ *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1962+ } else {
1963+ *cptr = cstr;
1964+ *alloc = SWIG_OLDOBJ;
1965+ }
1966+ }
1967+ }
1968+ if (psize) *psize = size;
1969+ return SWIG_OK;
1970+ } else {
1971+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1972+ if (pchar_descriptor) {
1973+ void* vptr = 0;
1974+ if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
1975+ if (cptr) *cptr = (char *)vptr;
1976+ if (psize) *psize = vptr ? (strlen((char*)vptr) + 1) : 0;
1977+ if (alloc) *alloc = SWIG_OLDOBJ;
1978+ return SWIG_OK;
1979+ }
1980+ }
1981+ }
1982+ return SWIG_TypeError;
1983+}
1984+
1985+
1986+SWIGINTERN int
1987+SWIG_AsCharArray(VALUE obj, char *val, size_t size)
1988+{
1989+ char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
1990+ int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
1991+ if (SWIG_IsOK(res)) {
1992+ if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
1993+ if (csize <= size) {
1994+ if (val) {
1995+ if (csize) memcpy(val, cptr, csize*sizeof(char));
1996+ if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
1997+ }
1998+ if (alloc == SWIG_NEWOBJ) {
1999+ free((char*)cptr);
2000+ res = SWIG_DelNewMask(res);
2001+ }
2002+ return res;
2003+ }
2004+ if (alloc == SWIG_NEWOBJ) free((char*)cptr);
2005+ }
2006+ return SWIG_TypeError;
2007+}
2008+
2009+
2010+SWIGINTERNINLINE VALUE
2011+SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2012+{
2013+ if (carray) {
2014+ if (size > LONG_MAX) {
2015+ swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2016+ return pchar_descriptor ?
2017+ SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : Qnil;
2018+ } else {
2019+ return rb_str_new(carray, (long)(size));
2020+ }
2021+ } else {
2022+ return Qnil;
2023+ }
2024+}
2025+
2026+
2027+SWIGINTERN VALUE
2028+SWIG_ruby_failed(void)
2029+{
2030+ return Qnil;
2031+}
2032+
2033+
2034+/*@SWIG:/usr/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2035+SWIGINTERN VALUE SWIG_AUX_NUM2DBL(VALUE *args)
2036+{
2037+ VALUE obj = args[0];
2038+ VALUE type = TYPE(obj);
2039+ double *res = (double *)(args[1]);
2040+ *res = NUM2DBL(obj);
2041+ return obj;
2042+}
2043+/*@SWIG@*/
2044+
2045+SWIGINTERN int
2046+SWIG_AsVal_double (VALUE obj, double *val)
2047+{
2048+ VALUE type = TYPE(obj);
2049+ if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
2050+ double v;
2051+ VALUE a[2];
2052+ a[0] = obj;
2053+ a[1] = (VALUE)(&v);
2054+ if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
2055+ if (val) *val = v;
2056+ return SWIG_OK;
2057+ }
2058+ }
2059+ return SWIG_TypeError;
2060+}
2061+
2062+
2063+/*@SWIG:/usr/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2064+SWIGINTERN VALUE SWIG_AUX_NUM2LONG(VALUE *args)
2065+{
2066+ VALUE obj = args[0];
2067+ VALUE type = TYPE(obj);
2068+ long *res = (long *)(args[1]);
2069+ *res = type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj);
2070+ return obj;
2071+}
2072+/*@SWIG@*/
2073+
2074+SWIGINTERN int
2075+SWIG_AsVal_long (VALUE obj, long* val)
2076+{
2077+ VALUE type = TYPE(obj);
2078+ if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
2079+ long v;
2080+ VALUE a[2];
2081+ a[0] = obj;
2082+ a[1] = (VALUE)(&v);
2083+ if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
2084+ if (val) *val = v;
2085+ return SWIG_OK;
2086+ }
2087+ }
2088+ return SWIG_TypeError;
2089+}
2090+
2091+
2092+SWIGINTERN int
2093+SWIG_AsVal_int (VALUE obj, int *val)
2094+{
2095+ long v;
2096+ int res = SWIG_AsVal_long (obj, &v);
2097+ if (SWIG_IsOK(res)) {
2098+ if ((v < INT_MIN || v > INT_MAX)) {
2099+ return SWIG_OverflowError;
2100+ } else {
2101+ if (val) *val = (int)(v);
2102+ }
2103+ }
2104+ return res;
2105+}
2106+
2107+
2108+SWIGINTERN int
2109+SWIG_AsVal_char (VALUE obj, char *val)
2110+{
2111+ int res = SWIG_AsCharArray(obj, val, 1);
2112+ if (!SWIG_IsOK(res)) {
2113+ long v;
2114+ res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
2115+ if (SWIG_IsOK(res)) {
2116+ if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
2117+ if (val) *val = (char)(v);
2118+ } else {
2119+ res = SWIG_OverflowError;
2120+ }
2121+ }
2122+ }
2123+ return res;
2124+}
2125+
2126+
2127+#include <float.h>
2128+
2129+
2130+SWIGINTERN int
2131+SWIG_AsVal_float (VALUE obj, float *val)
2132+{
2133+ double v;
2134+ int res = SWIG_AsVal_double (obj, &v);
2135+ if (SWIG_IsOK(res)) {
2136+ if ((v < -FLT_MAX || v > FLT_MAX)) {
2137+ return SWIG_OverflowError;
2138+ } else {
2139+ if (val) *val = (float)(v);
2140+ }
2141+ }
2142+ return res;
2143+}
2144+
2145+
2146+SWIGINTERNINLINE VALUE
2147+SWIG_From_float (float value)
2148+{
2149+ return SWIG_From_double (value);
2150+}
2151+
2152+
2153+SWIGINTERNINLINE VALUE
2154+SWIG_FromCharPtr(const char *cptr)
2155+{
2156+ return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2157+}
2158+
2159+
2160+/*@SWIG:/usr/share/swig/1.3.40/ruby/rubyprimtypes.swg,23,%ruby_aux_method@*/
2161+SWIGINTERN VALUE SWIG_AUX_NUM2ULONG(VALUE *args)
2162+{
2163+ VALUE obj = args[0];
2164+ VALUE type = TYPE(obj);
2165+ unsigned long *res = (unsigned long *)(args[1]);
2166+ *res = type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj);
2167+ return obj;
2168+}
2169+/*@SWIG@*/
2170+
2171+SWIGINTERN int
2172+SWIG_AsVal_unsigned_SS_long (VALUE obj, unsigned long *val)
2173+{
2174+ VALUE type = TYPE(obj);
2175+ if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
2176+ unsigned long v;
2177+ VALUE a[2];
2178+ a[0] = obj;
2179+ a[1] = (VALUE)(&v);
2180+ if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
2181+ if (val) *val = v;
2182+ return SWIG_OK;
2183+ }
2184+ }
2185+ return SWIG_TypeError;
2186+}
2187+
2188+
2189+SWIGINTERN int
2190+SWIG_AsVal_unsigned_SS_int (VALUE obj, unsigned int *val)
2191+{
2192+ unsigned long v;
2193+ int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2194+ if (SWIG_IsOK(res)) {
2195+ if ((v > UINT_MAX)) {
2196+ return SWIG_OverflowError;
2197+ } else {
2198+ if (val) *val = (unsigned int)(v);
2199+ }
2200+ }
2201+ return res;
2202+}
2203+
2204+
2205+SWIGINTERNINLINE VALUE
2206+SWIG_From_unsigned_SS_long (unsigned long value)
2207+{
2208+ return ULONG2NUM(value);
2209+}
2210+
2211+
2212+SWIGINTERNINLINE VALUE
2213+SWIG_From_unsigned_SS_int (unsigned int value)
2214+{
2215+ return SWIG_From_unsigned_SS_long (value);
2216+}
2217+
2218+
2219+typedef struct {
2220+
2221+
2222+
2223+
2224+
2225+ short detail;
2226+ unsigned char category;
2227+ unsigned char level;
2228+
2229+ } MRC_Status_t_status;
2230+
2231+
2232+
2233+SWIGINTERN int
2234+SWIG_AsVal_short (VALUE obj, short *val)
2235+{
2236+ long v;
2237+ int res = SWIG_AsVal_long (obj, &v);
2238+ if (SWIG_IsOK(res)) {
2239+ if ((v < SHRT_MIN || v > SHRT_MAX)) {
2240+ return SWIG_OverflowError;
2241+ } else {
2242+ if (val) *val = (short)(v);
2243+ }
2244+ }
2245+ return res;
2246+}
2247+
2248+
2249+SWIGINTERNINLINE VALUE
2250+SWIG_From_short (short value)
2251+{
2252+ return SWIG_From_long (value);
2253+}
2254+
2255+
2256+SWIGINTERN int
2257+SWIG_AsVal_unsigned_SS_char (VALUE obj, unsigned char *val)
2258+{
2259+ unsigned long v;
2260+ int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
2261+ if (SWIG_IsOK(res)) {
2262+ if ((v > UCHAR_MAX)) {
2263+ return SWIG_OverflowError;
2264+ } else {
2265+ if (val) *val = (unsigned char)(v);
2266+ }
2267+ }
2268+ return res;
2269+}
2270+
2271+
2272+SWIGINTERNINLINE VALUE
2273+SWIG_From_unsigned_SS_char (unsigned char value)
2274+{
2275+ return SWIG_From_unsigned_SS_long (value);
2276+}
2277+
2278+
2279+SWIGINTERNINLINE int
2280+SWIG_AsVal_size_t (VALUE obj, size_t *val)
2281+{
2282+ unsigned long v;
2283+ int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
2284+ if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2285+ return res;
2286+}
2287+
2288+
2289+SWIGINTERNINLINE VALUE
2290+SWIG_From_size_t (size_t value)
2291+{
2292+ return SWIG_From_unsigned_SS_long ((unsigned long)(value));
2293+}
2294+
2295+
2296+
2297+
2298+
2299+SWIGINTERNINLINE VALUE
2300+SWIG_From_char (char c)
2301+{
2302+ return SWIG_FromCharPtrAndSize(&c,1);
2303+}
2304+
2305+swig_class SwigClassEulerAngleInfo;
2306+
2307+SWIGINTERN VALUE
2308+_wrap_EulerAngleInfo_EAMode_set(int argc, VALUE *argv, VALUE self) {
2309+ EulerAngleInfo *arg1 = (EulerAngleInfo *) 0 ;
2310+ char *arg2 ;
2311+ void *argp1 = 0 ;
2312+ int res1 = 0 ;
2313+ char temp2[5] ;
2314+ int res2 ;
2315+
2316+ if ((argc < 1) || (argc > 1)) {
2317+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2318+ }
2319+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EulerAngleInfo, 0 | 0 );
2320+ if (!SWIG_IsOK(res1)) {
2321+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngleInfo *","EAMode", 1, self ));
2322+ }
2323+ arg1 = (EulerAngleInfo *)(argp1);
2324+ res2 = SWIG_AsCharArray(argv[0], temp2, 5);
2325+ if (!SWIG_IsOK(res2)) {
2326+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [5]","EAMode", 2, argv[0] ));
2327+ }
2328+ arg2 = (char *)(temp2);
2329+ if (arg2) memcpy(arg1->EAMode,arg2,5*sizeof(char));
2330+ else memset(arg1->EAMode,0,5*sizeof(char));
2331+ return Qnil;
2332+fail:
2333+ return Qnil;
2334+}
2335+
2336+
2337+SWIGINTERN VALUE
2338+_wrap_EulerAngleInfo_EAMode_get(int argc, VALUE *argv, VALUE self) {
2339+ EulerAngleInfo *arg1 = (EulerAngleInfo *) 0 ;
2340+ void *argp1 = 0 ;
2341+ int res1 = 0 ;
2342+ char *result = 0 ;
2343+ VALUE vresult = Qnil;
2344+
2345+ if ((argc < 0) || (argc > 0)) {
2346+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2347+ }
2348+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EulerAngleInfo, 0 | 0 );
2349+ if (!SWIG_IsOK(res1)) {
2350+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngleInfo *","EAMode", 1, self ));
2351+ }
2352+ arg1 = (EulerAngleInfo *)(argp1);
2353+ result = (char *)(char *) ((arg1)->EAMode);
2354+ {
2355+ size_t size = 5;
2356+
2357+ while (size && (result[size - 1] == '\0')) --size;
2358+
2359+ vresult = SWIG_FromCharPtrAndSize(result, size);
2360+ }
2361+ return vresult;
2362+fail:
2363+ return Qnil;
2364+}
2365+
2366+
2367+SWIGINTERN VALUE
2368+_wrap_EulerAngleInfo_Rot1_set(int argc, VALUE *argv, VALUE self) {
2369+ EulerAngleInfo *arg1 = (EulerAngleInfo *) 0 ;
2370+ double arg2 ;
2371+ void *argp1 = 0 ;
2372+ int res1 = 0 ;
2373+ double val2 ;
2374+ int ecode2 = 0 ;
2375+
2376+ if ((argc < 1) || (argc > 1)) {
2377+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2378+ }
2379+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EulerAngleInfo, 0 | 0 );
2380+ if (!SWIG_IsOK(res1)) {
2381+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngleInfo *","Rot1", 1, self ));
2382+ }
2383+ arg1 = (EulerAngleInfo *)(argp1);
2384+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
2385+ if (!SWIG_IsOK(ecode2)) {
2386+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Rot1", 2, argv[0] ));
2387+ }
2388+ arg2 = (double)(val2);
2389+ if (arg1) (arg1)->Rot1 = arg2;
2390+ return Qnil;
2391+fail:
2392+ return Qnil;
2393+}
2394+
2395+
2396+SWIGINTERN VALUE
2397+_wrap_EulerAngleInfo_Rot1_get(int argc, VALUE *argv, VALUE self) {
2398+ EulerAngleInfo *arg1 = (EulerAngleInfo *) 0 ;
2399+ void *argp1 = 0 ;
2400+ int res1 = 0 ;
2401+ double result;
2402+ VALUE vresult = Qnil;
2403+
2404+ if ((argc < 0) || (argc > 0)) {
2405+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2406+ }
2407+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EulerAngleInfo, 0 | 0 );
2408+ if (!SWIG_IsOK(res1)) {
2409+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngleInfo *","Rot1", 1, self ));
2410+ }
2411+ arg1 = (EulerAngleInfo *)(argp1);
2412+ result = (double) ((arg1)->Rot1);
2413+ vresult = SWIG_From_double((double)(result));
2414+ return vresult;
2415+fail:
2416+ return Qnil;
2417+}
2418+
2419+
2420+SWIGINTERN VALUE
2421+_wrap_EulerAngleInfo_Rot2_set(int argc, VALUE *argv, VALUE self) {
2422+ EulerAngleInfo *arg1 = (EulerAngleInfo *) 0 ;
2423+ double arg2 ;
2424+ void *argp1 = 0 ;
2425+ int res1 = 0 ;
2426+ double val2 ;
2427+ int ecode2 = 0 ;
2428+
2429+ if ((argc < 1) || (argc > 1)) {
2430+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2431+ }
2432+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EulerAngleInfo, 0 | 0 );
2433+ if (!SWIG_IsOK(res1)) {
2434+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngleInfo *","Rot2", 1, self ));
2435+ }
2436+ arg1 = (EulerAngleInfo *)(argp1);
2437+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
2438+ if (!SWIG_IsOK(ecode2)) {
2439+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Rot2", 2, argv[0] ));
2440+ }
2441+ arg2 = (double)(val2);
2442+ if (arg1) (arg1)->Rot2 = arg2;
2443+ return Qnil;
2444+fail:
2445+ return Qnil;
2446+}
2447+
2448+
2449+SWIGINTERN VALUE
2450+_wrap_EulerAngleInfo_Rot2_get(int argc, VALUE *argv, VALUE self) {
2451+ EulerAngleInfo *arg1 = (EulerAngleInfo *) 0 ;
2452+ void *argp1 = 0 ;
2453+ int res1 = 0 ;
2454+ double result;
2455+ VALUE vresult = Qnil;
2456+
2457+ if ((argc < 0) || (argc > 0)) {
2458+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2459+ }
2460+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EulerAngleInfo, 0 | 0 );
2461+ if (!SWIG_IsOK(res1)) {
2462+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngleInfo *","Rot2", 1, self ));
2463+ }
2464+ arg1 = (EulerAngleInfo *)(argp1);
2465+ result = (double) ((arg1)->Rot2);
2466+ vresult = SWIG_From_double((double)(result));
2467+ return vresult;
2468+fail:
2469+ return Qnil;
2470+}
2471+
2472+
2473+SWIGINTERN VALUE
2474+_wrap_EulerAngleInfo_Rot3_set(int argc, VALUE *argv, VALUE self) {
2475+ EulerAngleInfo *arg1 = (EulerAngleInfo *) 0 ;
2476+ double arg2 ;
2477+ void *argp1 = 0 ;
2478+ int res1 = 0 ;
2479+ double val2 ;
2480+ int ecode2 = 0 ;
2481+
2482+ if ((argc < 1) || (argc > 1)) {
2483+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2484+ }
2485+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EulerAngleInfo, 0 | 0 );
2486+ if (!SWIG_IsOK(res1)) {
2487+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngleInfo *","Rot3", 1, self ));
2488+ }
2489+ arg1 = (EulerAngleInfo *)(argp1);
2490+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
2491+ if (!SWIG_IsOK(ecode2)) {
2492+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","Rot3", 2, argv[0] ));
2493+ }
2494+ arg2 = (double)(val2);
2495+ if (arg1) (arg1)->Rot3 = arg2;
2496+ return Qnil;
2497+fail:
2498+ return Qnil;
2499+}
2500+
2501+
2502+SWIGINTERN VALUE
2503+_wrap_EulerAngleInfo_Rot3_get(int argc, VALUE *argv, VALUE self) {
2504+ EulerAngleInfo *arg1 = (EulerAngleInfo *) 0 ;
2505+ void *argp1 = 0 ;
2506+ int res1 = 0 ;
2507+ double result;
2508+ VALUE vresult = Qnil;
2509+
2510+ if ((argc < 0) || (argc > 0)) {
2511+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2512+ }
2513+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_EulerAngleInfo, 0 | 0 );
2514+ if (!SWIG_IsOK(res1)) {
2515+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngleInfo *","Rot3", 1, self ));
2516+ }
2517+ arg1 = (EulerAngleInfo *)(argp1);
2518+ result = (double) ((arg1)->Rot3);
2519+ vresult = SWIG_From_double((double)(result));
2520+ return vresult;
2521+fail:
2522+ return Qnil;
2523+}
2524+
2525+
2526+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
2527+SWIGINTERN VALUE
2528+_wrap_EulerAngleInfo_allocate(VALUE self) {
2529+#else
2530+ SWIGINTERN VALUE
2531+ _wrap_EulerAngleInfo_allocate(int argc, VALUE *argv, VALUE self) {
2532+#endif
2533+
2534+
2535+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_EulerAngleInfo);
2536+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
2537+ rb_obj_call_init(vresult, argc, argv);
2538+#endif
2539+ return vresult;
2540+ }
2541+
2542+
2543+SWIGINTERN VALUE
2544+_wrap_new_EulerAngleInfo(int argc, VALUE *argv, VALUE self) {
2545+ EulerAngleInfo *result = 0 ;
2546+
2547+ if ((argc < 0) || (argc > 0)) {
2548+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
2549+ }
2550+ result = (EulerAngleInfo *)calloc(1, sizeof(EulerAngleInfo));
2551+ DATA_PTR(self) = result;
2552+ return self;
2553+fail:
2554+ return Qnil;
2555+}
2556+
2557+
2558+SWIGINTERN void
2559+free_EulerAngleInfo(EulerAngleInfo *arg1) {
2560+ free((char *) arg1);
2561+}
2562+
2563+SWIGINTERN VALUE
2564+_wrap_matrix3DInit(int argc, VALUE *argv, VALUE self) {
2565+ matrix3DParaTypeReal (*arg1)[4] ;
2566+ void *argp1 = 0 ;
2567+ int res1 = 0 ;
2568+
2569+ if ((argc < 1) || (argc > 1)) {
2570+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2571+ }
2572+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
2573+ if (!SWIG_IsOK(res1)) {
2574+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DInit", 1, argv[0] ));
2575+ }
2576+ arg1 = (float (*)[4])(argp1);
2577+ matrix3DInit((float (*)[4])arg1);
2578+ return Qnil;
2579+fail:
2580+ return Qnil;
2581+}
2582+
2583+
2584+SWIGINTERN VALUE
2585+_wrap_matrix3DFromRotationMatrix(int argc, VALUE *argv, VALUE self) {
2586+ matrix3DParaTypeReal (*arg1)[4] ;
2587+ Array arg2 ;
2588+ void *argp1 = 0 ;
2589+ int res1 = 0 ;
2590+ void *argp2 ;
2591+ int res2 = 0 ;
2592+
2593+ if ((argc < 2) || (argc > 2)) {
2594+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2595+ }
2596+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
2597+ if (!SWIG_IsOK(res1)) {
2598+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DFromRotationMatrix", 1, argv[0] ));
2599+ }
2600+ arg1 = (float (*)[4])(argp1);
2601+ {
2602+ res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Array, 0 );
2603+ if (!SWIG_IsOK(res2)) {
2604+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Array","matrix3DFromRotationMatrix", 2, argv[1] ));
2605+ }
2606+ if (!argp2) {
2607+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Array","matrix3DFromRotationMatrix", 2, argv[1]));
2608+ } else {
2609+ arg2 = *((Array *)(argp2));
2610+ }
2611+ }
2612+ matrix3DFromRotationMatrix((float (*)[4])arg1,arg2);
2613+ return Qnil;
2614+fail:
2615+ return Qnil;
2616+}
2617+
2618+
2619+SWIGINTERN VALUE
2620+_wrap_matrix3DInverse(int argc, VALUE *argv, VALUE self) {
2621+ matrix3DParaTypeReal (*arg1)[4] ;
2622+ void *argp1 = 0 ;
2623+ int res1 = 0 ;
2624+
2625+ if ((argc < 1) || (argc > 1)) {
2626+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2627+ }
2628+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
2629+ if (!SWIG_IsOK(res1)) {
2630+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DInverse", 1, argv[0] ));
2631+ }
2632+ arg1 = (float (*)[4])(argp1);
2633+ matrix3DInverse((float (*)[4])arg1);
2634+ return Qnil;
2635+fail:
2636+ return Qnil;
2637+}
2638+
2639+
2640+SWIGINTERN VALUE
2641+_wrap_matrix3DMultiply(int argc, VALUE *argv, VALUE self) {
2642+ matrix3DParaTypeReal (*arg1)[4] ;
2643+ matrix3DParaTypeReal (*arg2)[4] ;
2644+ void *argp1 = 0 ;
2645+ int res1 = 0 ;
2646+ void *argp2 = 0 ;
2647+ int res2 = 0 ;
2648+
2649+ if ((argc < 2) || (argc > 2)) {
2650+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2651+ }
2652+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
2653+ if (!SWIG_IsOK(res1)) {
2654+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DMultiply", 1, argv[0] ));
2655+ }
2656+ arg1 = (float (*)[4])(argp1);
2657+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_a_4__float, 0 | 0 );
2658+ if (!SWIG_IsOK(res2)) {
2659+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float [4][4]","matrix3DMultiply", 2, argv[1] ));
2660+ }
2661+ arg2 = (float (*)[4])(argp2);
2662+ matrix3DMultiply((float (*)[4])arg1,(float (*)[4])arg2);
2663+ return Qnil;
2664+fail:
2665+ return Qnil;
2666+}
2667+
2668+
2669+SWIGINTERN VALUE
2670+_wrap_matrix3DMultiplyInv(int argc, VALUE *argv, VALUE self) {
2671+ matrix3DParaTypeReal (*arg1)[4] ;
2672+ matrix3DParaTypeReal (*arg2)[4] ;
2673+ void *argp1 = 0 ;
2674+ int res1 = 0 ;
2675+ void *argp2 = 0 ;
2676+ int res2 = 0 ;
2677+
2678+ if ((argc < 2) || (argc > 2)) {
2679+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2680+ }
2681+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
2682+ if (!SWIG_IsOK(res1)) {
2683+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DMultiplyInv", 1, argv[0] ));
2684+ }
2685+ arg1 = (float (*)[4])(argp1);
2686+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_a_4__float, 0 | 0 );
2687+ if (!SWIG_IsOK(res2)) {
2688+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float [4][4]","matrix3DMultiplyInv", 2, argv[1] ));
2689+ }
2690+ arg2 = (float (*)[4])(argp2);
2691+ matrix3DMultiplyInv((float (*)[4])arg1,(float (*)[4])arg2);
2692+ return Qnil;
2693+fail:
2694+ return Qnil;
2695+}
2696+
2697+
2698+SWIGINTERN VALUE
2699+_wrap_matrix3DMultiplyVector(int argc, VALUE *argv, VALUE self) {
2700+ floatVector *arg1 = (floatVector *) 0 ;
2701+ matrix3DParaTypeReal (*arg2)[4] ;
2702+ void *argp1 = 0 ;
2703+ int res1 = 0 ;
2704+ void *argp2 = 0 ;
2705+ int res2 = 0 ;
2706+
2707+ if ((argc < 2) || (argc > 2)) {
2708+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2709+ }
2710+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_floatVector, 0 | 0 );
2711+ if (!SWIG_IsOK(res1)) {
2712+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "floatVector *","matrix3DMultiplyVector", 1, argv[0] ));
2713+ }
2714+ arg1 = (floatVector *)(argp1);
2715+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_a_4__float, 0 | 0 );
2716+ if (!SWIG_IsOK(res2)) {
2717+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float [4][4]","matrix3DMultiplyVector", 2, argv[1] ));
2718+ }
2719+ arg2 = (float (*)[4])(argp2);
2720+ matrix3DMultiplyVector(arg1,(float (*)[4])arg2);
2721+ return Qnil;
2722+fail:
2723+ return Qnil;
2724+}
2725+
2726+
2727+SWIGINTERN VALUE
2728+_wrap_matrix3DMultiplyVectors(int argc, VALUE *argv, VALUE self) {
2729+ floatVector *arg1 = (floatVector *) 0 ;
2730+ int arg2 ;
2731+ matrix3DParaTypeReal (*arg3)[4] ;
2732+ void *argp1 = 0 ;
2733+ int res1 = 0 ;
2734+ int val2 ;
2735+ int ecode2 = 0 ;
2736+ void *argp3 = 0 ;
2737+ int res3 = 0 ;
2738+
2739+ if ((argc < 3) || (argc > 3)) {
2740+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
2741+ }
2742+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_floatVector, 0 | 0 );
2743+ if (!SWIG_IsOK(res1)) {
2744+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "floatVector *","matrix3DMultiplyVectors", 1, argv[0] ));
2745+ }
2746+ arg1 = (floatVector *)(argp1);
2747+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
2748+ if (!SWIG_IsOK(ecode2)) {
2749+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","matrix3DMultiplyVectors", 2, argv[1] ));
2750+ }
2751+ arg2 = (int)(val2);
2752+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_a_4__float, 0 | 0 );
2753+ if (!SWIG_IsOK(res3)) {
2754+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float [4][4]","matrix3DMultiplyVectors", 3, argv[2] ));
2755+ }
2756+ arg3 = (float (*)[4])(argp3);
2757+ matrix3DMultiplyVectors(arg1,arg2,(float (*)[4])arg3);
2758+ return Qnil;
2759+fail:
2760+ return Qnil;
2761+}
2762+
2763+
2764+SWIGINTERN VALUE
2765+_wrap_matrix3DFileFormat(int argc, VALUE *argv, VALUE self) {
2766+ FILE *arg1 = (FILE *) 0 ;
2767+ void *argp1 = 0 ;
2768+ int res1 = 0 ;
2769+
2770+ if ((argc < 1) || (argc > 1)) {
2771+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
2772+ }
2773+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 );
2774+ if (!SWIG_IsOK(res1)) {
2775+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FILE *","matrix3DFileFormat", 1, argv[0] ));
2776+ }
2777+ arg1 = (FILE *)(argp1);
2778+ matrix3DFileFormat(arg1);
2779+ return Qnil;
2780+fail:
2781+ return Qnil;
2782+}
2783+
2784+
2785+SWIGINTERN VALUE
2786+_wrap_matrix3DFileRead(int argc, VALUE *argv, VALUE self) {
2787+ FILE *arg1 = (FILE *) 0 ;
2788+ matrix3DParaTypeReal (*arg2)[4] ;
2789+ void *argp1 = 0 ;
2790+ int res1 = 0 ;
2791+ void *argp2 = 0 ;
2792+ int res2 = 0 ;
2793+
2794+ if ((argc < 2) || (argc > 2)) {
2795+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2796+ }
2797+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 );
2798+ if (!SWIG_IsOK(res1)) {
2799+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FILE *","matrix3DFileRead", 1, argv[0] ));
2800+ }
2801+ arg1 = (FILE *)(argp1);
2802+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_a_4__float, 0 | 0 );
2803+ if (!SWIG_IsOK(res2)) {
2804+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float [4][4]","matrix3DFileRead", 2, argv[1] ));
2805+ }
2806+ arg2 = (float (*)[4])(argp2);
2807+ matrix3DFileRead(arg1,(float (*)[4])arg2);
2808+ return Qnil;
2809+fail:
2810+ return Qnil;
2811+}
2812+
2813+
2814+SWIGINTERN VALUE
2815+_wrap_matrix3DFileWrite(int argc, VALUE *argv, VALUE self) {
2816+ FILE *arg1 = (FILE *) 0 ;
2817+ matrix3DParaTypeReal (*arg2)[4] ;
2818+ void *argp1 = 0 ;
2819+ int res1 = 0 ;
2820+ void *argp2 = 0 ;
2821+ int res2 = 0 ;
2822+
2823+ if ((argc < 2) || (argc > 2)) {
2824+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
2825+ }
2826+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_FILE, 0 | 0 );
2827+ if (!SWIG_IsOK(res1)) {
2828+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FILE *","matrix3DFileWrite", 1, argv[0] ));
2829+ }
2830+ arg1 = (FILE *)(argp1);
2831+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_a_4__float, 0 | 0 );
2832+ if (!SWIG_IsOK(res2)) {
2833+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float [4][4]","matrix3DFileWrite", 2, argv[1] ));
2834+ }
2835+ arg2 = (float (*)[4])(argp2);
2836+ matrix3DFileWrite(arg1,(float (*)[4])arg2);
2837+ return Qnil;
2838+fail:
2839+ return Qnil;
2840+}
2841+
2842+
2843+SWIGINTERN VALUE
2844+_wrap_matrix3DRotationSet(int argc, VALUE *argv, VALUE self) {
2845+ matrix3DParaTypeReal (*arg1)[4] ;
2846+ char arg2 ;
2847+ matrix3DParaTypeReal arg3 ;
2848+ long arg4 ;
2849+ void *argp1 = 0 ;
2850+ int res1 = 0 ;
2851+ char val2 ;
2852+ int ecode2 = 0 ;
2853+ float val3 ;
2854+ int ecode3 = 0 ;
2855+ long val4 ;
2856+ int ecode4 = 0 ;
2857+
2858+ if ((argc < 4) || (argc > 4)) {
2859+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
2860+ }
2861+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
2862+ if (!SWIG_IsOK(res1)) {
2863+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DRotationSet", 1, argv[0] ));
2864+ }
2865+ arg1 = (float (*)[4])(argp1);
2866+ ecode2 = SWIG_AsVal_char(argv[1], &val2);
2867+ if (!SWIG_IsOK(ecode2)) {
2868+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","matrix3DRotationSet", 2, argv[1] ));
2869+ }
2870+ arg2 = (char)(val2);
2871+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
2872+ if (!SWIG_IsOK(ecode3)) {
2873+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSet", 3, argv[2] ));
2874+ }
2875+ arg3 = (matrix3DParaTypeReal)(val3);
2876+ ecode4 = SWIG_AsVal_long(argv[3], &val4);
2877+ if (!SWIG_IsOK(ecode4)) {
2878+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "long","matrix3DRotationSet", 4, argv[3] ));
2879+ }
2880+ arg4 = (long)(val4);
2881+ matrix3DRotationSet((float (*)[4])arg1,arg2,arg3,arg4);
2882+ return Qnil;
2883+fail:
2884+ return Qnil;
2885+}
2886+
2887+
2888+SWIGINTERN VALUE
2889+_wrap_matrix3DTranslationSet(int argc, VALUE *argv, VALUE self) {
2890+ matrix3DParaTypeReal (*arg1)[4] ;
2891+ matrix3DParaTypeReal arg2 ;
2892+ matrix3DParaTypeReal arg3 ;
2893+ matrix3DParaTypeReal arg4 ;
2894+ long arg5 ;
2895+ void *argp1 = 0 ;
2896+ int res1 = 0 ;
2897+ float val2 ;
2898+ int ecode2 = 0 ;
2899+ float val3 ;
2900+ int ecode3 = 0 ;
2901+ float val4 ;
2902+ int ecode4 = 0 ;
2903+ long val5 ;
2904+ int ecode5 = 0 ;
2905+
2906+ if ((argc < 5) || (argc > 5)) {
2907+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
2908+ }
2909+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
2910+ if (!SWIG_IsOK(res1)) {
2911+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DTranslationSet", 1, argv[0] ));
2912+ }
2913+ arg1 = (float (*)[4])(argp1);
2914+ ecode2 = SWIG_AsVal_float(argv[1], &val2);
2915+ if (!SWIG_IsOK(ecode2)) {
2916+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DTranslationSet", 2, argv[1] ));
2917+ }
2918+ arg2 = (matrix3DParaTypeReal)(val2);
2919+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
2920+ if (!SWIG_IsOK(ecode3)) {
2921+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DTranslationSet", 3, argv[2] ));
2922+ }
2923+ arg3 = (matrix3DParaTypeReal)(val3);
2924+ ecode4 = SWIG_AsVal_float(argv[3], &val4);
2925+ if (!SWIG_IsOK(ecode4)) {
2926+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DTranslationSet", 4, argv[3] ));
2927+ }
2928+ arg4 = (matrix3DParaTypeReal)(val4);
2929+ ecode5 = SWIG_AsVal_long(argv[4], &val5);
2930+ if (!SWIG_IsOK(ecode5)) {
2931+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","matrix3DTranslationSet", 5, argv[4] ));
2932+ }
2933+ arg5 = (long)(val5);
2934+ matrix3DTranslationSet((float (*)[4])arg1,arg2,arg3,arg4,arg5);
2935+ return Qnil;
2936+fail:
2937+ return Qnil;
2938+}
2939+
2940+
2941+SWIGINTERN VALUE
2942+_wrap_matrix3DRotationSetXYZ(int argc, VALUE *argv, VALUE self) {
2943+ matrix3DParaTypeReal (*arg1)[4] ;
2944+ matrix3DParaTypeReal arg2 ;
2945+ matrix3DParaTypeReal arg3 ;
2946+ matrix3DParaTypeReal arg4 ;
2947+ long arg5 ;
2948+ void *argp1 = 0 ;
2949+ int res1 = 0 ;
2950+ float val2 ;
2951+ int ecode2 = 0 ;
2952+ float val3 ;
2953+ int ecode3 = 0 ;
2954+ float val4 ;
2955+ int ecode4 = 0 ;
2956+ long val5 ;
2957+ int ecode5 = 0 ;
2958+
2959+ if ((argc < 5) || (argc > 5)) {
2960+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
2961+ }
2962+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
2963+ if (!SWIG_IsOK(res1)) {
2964+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DRotationSetXYZ", 1, argv[0] ));
2965+ }
2966+ arg1 = (float (*)[4])(argp1);
2967+ ecode2 = SWIG_AsVal_float(argv[1], &val2);
2968+ if (!SWIG_IsOK(ecode2)) {
2969+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetXYZ", 2, argv[1] ));
2970+ }
2971+ arg2 = (matrix3DParaTypeReal)(val2);
2972+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
2973+ if (!SWIG_IsOK(ecode3)) {
2974+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetXYZ", 3, argv[2] ));
2975+ }
2976+ arg3 = (matrix3DParaTypeReal)(val3);
2977+ ecode4 = SWIG_AsVal_float(argv[3], &val4);
2978+ if (!SWIG_IsOK(ecode4)) {
2979+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetXYZ", 4, argv[3] ));
2980+ }
2981+ arg4 = (matrix3DParaTypeReal)(val4);
2982+ ecode5 = SWIG_AsVal_long(argv[4], &val5);
2983+ if (!SWIG_IsOK(ecode5)) {
2984+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","matrix3DRotationSetXYZ", 5, argv[4] ));
2985+ }
2986+ arg5 = (long)(val5);
2987+ matrix3DRotationSetXYZ((float (*)[4])arg1,arg2,arg3,arg4,arg5);
2988+ return Qnil;
2989+fail:
2990+ return Qnil;
2991+}
2992+
2993+
2994+SWIGINTERN VALUE
2995+_wrap_matrix3DRotationSetZYX(int argc, VALUE *argv, VALUE self) {
2996+ matrix3DParaTypeReal (*arg1)[4] ;
2997+ matrix3DParaTypeReal arg2 ;
2998+ matrix3DParaTypeReal arg3 ;
2999+ matrix3DParaTypeReal arg4 ;
3000+ long arg5 ;
3001+ void *argp1 = 0 ;
3002+ int res1 = 0 ;
3003+ float val2 ;
3004+ int ecode2 = 0 ;
3005+ float val3 ;
3006+ int ecode3 = 0 ;
3007+ float val4 ;
3008+ int ecode4 = 0 ;
3009+ long val5 ;
3010+ int ecode5 = 0 ;
3011+
3012+ if ((argc < 5) || (argc > 5)) {
3013+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
3014+ }
3015+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
3016+ if (!SWIG_IsOK(res1)) {
3017+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DRotationSetZYX", 1, argv[0] ));
3018+ }
3019+ arg1 = (float (*)[4])(argp1);
3020+ ecode2 = SWIG_AsVal_float(argv[1], &val2);
3021+ if (!SWIG_IsOK(ecode2)) {
3022+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetZYX", 2, argv[1] ));
3023+ }
3024+ arg2 = (matrix3DParaTypeReal)(val2);
3025+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
3026+ if (!SWIG_IsOK(ecode3)) {
3027+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetZYX", 3, argv[2] ));
3028+ }
3029+ arg3 = (matrix3DParaTypeReal)(val3);
3030+ ecode4 = SWIG_AsVal_float(argv[3], &val4);
3031+ if (!SWIG_IsOK(ecode4)) {
3032+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetZYX", 4, argv[3] ));
3033+ }
3034+ arg4 = (matrix3DParaTypeReal)(val4);
3035+ ecode5 = SWIG_AsVal_long(argv[4], &val5);
3036+ if (!SWIG_IsOK(ecode5)) {
3037+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","matrix3DRotationSetZYX", 5, argv[4] ));
3038+ }
3039+ arg5 = (long)(val5);
3040+ matrix3DRotationSetZYX((float (*)[4])arg1,arg2,arg3,arg4,arg5);
3041+ return Qnil;
3042+fail:
3043+ return Qnil;
3044+}
3045+
3046+
3047+SWIGINTERN VALUE
3048+_wrap_matrix3DRotationSetZXY(int argc, VALUE *argv, VALUE self) {
3049+ matrix3DParaTypeReal (*arg1)[4] ;
3050+ matrix3DParaTypeReal arg2 ;
3051+ matrix3DParaTypeReal arg3 ;
3052+ matrix3DParaTypeReal arg4 ;
3053+ long arg5 ;
3054+ void *argp1 = 0 ;
3055+ int res1 = 0 ;
3056+ float val2 ;
3057+ int ecode2 = 0 ;
3058+ float val3 ;
3059+ int ecode3 = 0 ;
3060+ float val4 ;
3061+ int ecode4 = 0 ;
3062+ long val5 ;
3063+ int ecode5 = 0 ;
3064+
3065+ if ((argc < 5) || (argc > 5)) {
3066+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
3067+ }
3068+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
3069+ if (!SWIG_IsOK(res1)) {
3070+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DRotationSetZXY", 1, argv[0] ));
3071+ }
3072+ arg1 = (float (*)[4])(argp1);
3073+ ecode2 = SWIG_AsVal_float(argv[1], &val2);
3074+ if (!SWIG_IsOK(ecode2)) {
3075+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetZXY", 2, argv[1] ));
3076+ }
3077+ arg2 = (matrix3DParaTypeReal)(val2);
3078+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
3079+ if (!SWIG_IsOK(ecode3)) {
3080+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetZXY", 3, argv[2] ));
3081+ }
3082+ arg3 = (matrix3DParaTypeReal)(val3);
3083+ ecode4 = SWIG_AsVal_float(argv[3], &val4);
3084+ if (!SWIG_IsOK(ecode4)) {
3085+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetZXY", 4, argv[3] ));
3086+ }
3087+ arg4 = (matrix3DParaTypeReal)(val4);
3088+ ecode5 = SWIG_AsVal_long(argv[4], &val5);
3089+ if (!SWIG_IsOK(ecode5)) {
3090+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","matrix3DRotationSetZXY", 5, argv[4] ));
3091+ }
3092+ arg5 = (long)(val5);
3093+ matrix3DRotationSetZXY((float (*)[4])arg1,arg2,arg3,arg4,arg5);
3094+ return Qnil;
3095+fail:
3096+ return Qnil;
3097+}
3098+
3099+
3100+SWIGINTERN VALUE
3101+_wrap_matrix3DRotationSetYXZ(int argc, VALUE *argv, VALUE self) {
3102+ matrix3DParaTypeReal (*arg1)[4] ;
3103+ matrix3DParaTypeReal arg2 ;
3104+ matrix3DParaTypeReal arg3 ;
3105+ matrix3DParaTypeReal arg4 ;
3106+ long arg5 ;
3107+ void *argp1 = 0 ;
3108+ int res1 = 0 ;
3109+ float val2 ;
3110+ int ecode2 = 0 ;
3111+ float val3 ;
3112+ int ecode3 = 0 ;
3113+ float val4 ;
3114+ int ecode4 = 0 ;
3115+ long val5 ;
3116+ int ecode5 = 0 ;
3117+
3118+ if ((argc < 5) || (argc > 5)) {
3119+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
3120+ }
3121+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
3122+ if (!SWIG_IsOK(res1)) {
3123+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DRotationSetYXZ", 1, argv[0] ));
3124+ }
3125+ arg1 = (float (*)[4])(argp1);
3126+ ecode2 = SWIG_AsVal_float(argv[1], &val2);
3127+ if (!SWIG_IsOK(ecode2)) {
3128+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetYXZ", 2, argv[1] ));
3129+ }
3130+ arg2 = (matrix3DParaTypeReal)(val2);
3131+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
3132+ if (!SWIG_IsOK(ecode3)) {
3133+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetYXZ", 3, argv[2] ));
3134+ }
3135+ arg3 = (matrix3DParaTypeReal)(val3);
3136+ ecode4 = SWIG_AsVal_float(argv[3], &val4);
3137+ if (!SWIG_IsOK(ecode4)) {
3138+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetYXZ", 4, argv[3] ));
3139+ }
3140+ arg4 = (matrix3DParaTypeReal)(val4);
3141+ ecode5 = SWIG_AsVal_long(argv[4], &val5);
3142+ if (!SWIG_IsOK(ecode5)) {
3143+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","matrix3DRotationSetYXZ", 5, argv[4] ));
3144+ }
3145+ arg5 = (long)(val5);
3146+ matrix3DRotationSetYXZ((float (*)[4])arg1,arg2,arg3,arg4,arg5);
3147+ return Qnil;
3148+fail:
3149+ return Qnil;
3150+}
3151+
3152+
3153+SWIGINTERN VALUE
3154+_wrap_matrix3DRotationSetFollowingEulerAngle(int argc, VALUE *argv, VALUE self) {
3155+ matrix3DParaTypeReal (*arg1)[4] ;
3156+ char *arg2 ;
3157+ matrix3DParaTypeReal arg3 ;
3158+ matrix3DParaTypeReal arg4 ;
3159+ matrix3DParaTypeReal arg5 ;
3160+ long arg6 ;
3161+ void *argp1 = 0 ;
3162+ int res1 = 0 ;
3163+ char temp2[4] ;
3164+ int res2 ;
3165+ float val3 ;
3166+ int ecode3 = 0 ;
3167+ float val4 ;
3168+ int ecode4 = 0 ;
3169+ float val5 ;
3170+ int ecode5 = 0 ;
3171+ long val6 ;
3172+ int ecode6 = 0 ;
3173+
3174+ if ((argc < 6) || (argc > 6)) {
3175+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
3176+ }
3177+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
3178+ if (!SWIG_IsOK(res1)) {
3179+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DRotationSetFollowingEulerAngle", 1, argv[0] ));
3180+ }
3181+ arg1 = (float (*)[4])(argp1);
3182+ res2 = SWIG_AsCharArray(argv[1], temp2, 4);
3183+ if (!SWIG_IsOK(res2)) {
3184+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const [4]","matrix3DRotationSetFollowingEulerAngle", 2, argv[1] ));
3185+ }
3186+ arg2 = (char *)(temp2);
3187+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
3188+ if (!SWIG_IsOK(ecode3)) {
3189+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetFollowingEulerAngle", 3, argv[2] ));
3190+ }
3191+ arg3 = (matrix3DParaTypeReal)(val3);
3192+ ecode4 = SWIG_AsVal_float(argv[3], &val4);
3193+ if (!SWIG_IsOK(ecode4)) {
3194+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetFollowingEulerAngle", 4, argv[3] ));
3195+ }
3196+ arg4 = (matrix3DParaTypeReal)(val4);
3197+ ecode5 = SWIG_AsVal_float(argv[4], &val5);
3198+ if (!SWIG_IsOK(ecode5)) {
3199+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationSetFollowingEulerAngle", 5, argv[4] ));
3200+ }
3201+ arg5 = (matrix3DParaTypeReal)(val5);
3202+ ecode6 = SWIG_AsVal_long(argv[5], &val6);
3203+ if (!SWIG_IsOK(ecode6)) {
3204+ SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "long","matrix3DRotationSetFollowingEulerAngle", 6, argv[5] ));
3205+ }
3206+ arg6 = (long)(val6);
3207+ matrix3DRotationSetFollowingEulerAngle((float (*)[4])arg1,(char const (*))arg2,arg3,arg4,arg5,arg6);
3208+ return Qnil;
3209+fail:
3210+ return Qnil;
3211+}
3212+
3213+
3214+SWIGINTERN VALUE
3215+_wrap_matrix3DRotationAntiSetFollowingEulerAngle(int argc, VALUE *argv, VALUE self) {
3216+ matrix3DParaTypeReal (*arg1)[4] ;
3217+ char *arg2 ;
3218+ matrix3DParaTypeReal arg3 ;
3219+ matrix3DParaTypeReal arg4 ;
3220+ matrix3DParaTypeReal arg5 ;
3221+ long arg6 ;
3222+ void *argp1 = 0 ;
3223+ int res1 = 0 ;
3224+ char temp2[4] ;
3225+ int res2 ;
3226+ float val3 ;
3227+ int ecode3 = 0 ;
3228+ float val4 ;
3229+ int ecode4 = 0 ;
3230+ float val5 ;
3231+ int ecode5 = 0 ;
3232+ long val6 ;
3233+ int ecode6 = 0 ;
3234+
3235+ if ((argc < 6) || (argc > 6)) {
3236+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
3237+ }
3238+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
3239+ if (!SWIG_IsOK(res1)) {
3240+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DRotationAntiSetFollowingEulerAngle", 1, argv[0] ));
3241+ }
3242+ arg1 = (float (*)[4])(argp1);
3243+ res2 = SWIG_AsCharArray(argv[1], temp2, 4);
3244+ if (!SWIG_IsOK(res2)) {
3245+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const [4]","matrix3DRotationAntiSetFollowingEulerAngle", 2, argv[1] ));
3246+ }
3247+ arg2 = (char *)(temp2);
3248+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
3249+ if (!SWIG_IsOK(ecode3)) {
3250+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationAntiSetFollowingEulerAngle", 3, argv[2] ));
3251+ }
3252+ arg3 = (matrix3DParaTypeReal)(val3);
3253+ ecode4 = SWIG_AsVal_float(argv[3], &val4);
3254+ if (!SWIG_IsOK(ecode4)) {
3255+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationAntiSetFollowingEulerAngle", 4, argv[3] ));
3256+ }
3257+ arg4 = (matrix3DParaTypeReal)(val4);
3258+ ecode5 = SWIG_AsVal_float(argv[4], &val5);
3259+ if (!SWIG_IsOK(ecode5)) {
3260+ SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "matrix3DParaTypeReal","matrix3DRotationAntiSetFollowingEulerAngle", 5, argv[4] ));
3261+ }
3262+ arg5 = (matrix3DParaTypeReal)(val5);
3263+ ecode6 = SWIG_AsVal_long(argv[5], &val6);
3264+ if (!SWIG_IsOK(ecode6)) {
3265+ SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "long","matrix3DRotationAntiSetFollowingEulerAngle", 6, argv[5] ));
3266+ }
3267+ arg6 = (long)(val6);
3268+ matrix3DRotationAntiSetFollowingEulerAngle((float (*)[4])arg1,(char const (*))arg2,arg3,arg4,arg5,arg6);
3269+ return Qnil;
3270+fail:
3271+ return Qnil;
3272+}
3273+
3274+
3275+SWIGINTERN VALUE
3276+_wrap_matrix3DEulerAngleGetFromMatrix3D(int argc, VALUE *argv, VALUE self) {
3277+ matrix3DParaTypeReal (*arg1)[4] ;
3278+ char *arg2 ;
3279+ matrix3DParaTypeReal *arg3 = (matrix3DParaTypeReal *) 0 ;
3280+ matrix3DParaTypeReal *arg4 = (matrix3DParaTypeReal *) 0 ;
3281+ matrix3DParaTypeReal *arg5 = (matrix3DParaTypeReal *) 0 ;
3282+ long arg6 ;
3283+ void *argp1 = 0 ;
3284+ int res1 = 0 ;
3285+ char temp2[4] ;
3286+ int res2 ;
3287+ void *argp3 = 0 ;
3288+ int res3 = 0 ;
3289+ void *argp4 = 0 ;
3290+ int res4 = 0 ;
3291+ void *argp5 = 0 ;
3292+ int res5 = 0 ;
3293+ long val6 ;
3294+ int ecode6 = 0 ;
3295+
3296+ if ((argc < 6) || (argc > 6)) {
3297+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
3298+ }
3299+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
3300+ if (!SWIG_IsOK(res1)) {
3301+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","matrix3DEulerAngleGetFromMatrix3D", 1, argv[0] ));
3302+ }
3303+ arg1 = (float (*)[4])(argp1);
3304+ res2 = SWIG_AsCharArray(argv[1], temp2, 4);
3305+ if (!SWIG_IsOK(res2)) {
3306+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const [4]","matrix3DEulerAngleGetFromMatrix3D", 2, argv[1] ));
3307+ }
3308+ arg2 = (char *)(temp2);
3309+ res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_float, 0 | 0 );
3310+ if (!SWIG_IsOK(res3)) {
3311+ SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "matrix3DParaTypeReal *","matrix3DEulerAngleGetFromMatrix3D", 3, argv[2] ));
3312+ }
3313+ arg3 = (matrix3DParaTypeReal *)(argp3);
3314+ res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_float, 0 | 0 );
3315+ if (!SWIG_IsOK(res4)) {
3316+ SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "matrix3DParaTypeReal *","matrix3DEulerAngleGetFromMatrix3D", 4, argv[3] ));
3317+ }
3318+ arg4 = (matrix3DParaTypeReal *)(argp4);
3319+ res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_float, 0 | 0 );
3320+ if (!SWIG_IsOK(res5)) {
3321+ SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "matrix3DParaTypeReal *","matrix3DEulerAngleGetFromMatrix3D", 5, argv[4] ));
3322+ }
3323+ arg5 = (matrix3DParaTypeReal *)(argp5);
3324+ ecode6 = SWIG_AsVal_long(argv[5], &val6);
3325+ if (!SWIG_IsOK(ecode6)) {
3326+ SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "long","matrix3DEulerAngleGetFromMatrix3D", 6, argv[5] ));
3327+ }
3328+ arg6 = (long)(val6);
3329+ matrix3DEulerAngleGetFromMatrix3D((float (*)[4])arg1,(char const (*))arg2,arg3,arg4,arg5,arg6);
3330+ return Qnil;
3331+fail:
3332+ return Qnil;
3333+}
3334+
3335+
3336+swig_class SwigClassQuat;
3337+
3338+SWIGINTERN VALUE
3339+_wrap_Quat_x_set(int argc, VALUE *argv, VALUE self) {
3340+ Quat *arg1 = (Quat *) 0 ;
3341+ float arg2 ;
3342+ void *argp1 = 0 ;
3343+ int res1 = 0 ;
3344+ float val2 ;
3345+ int ecode2 = 0 ;
3346+
3347+ if ((argc < 1) || (argc > 1)) {
3348+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3349+ }
3350+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Quat, 0 | 0 );
3351+ if (!SWIG_IsOK(res1)) {
3352+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat *","x", 1, self ));
3353+ }
3354+ arg1 = (Quat *)(argp1);
3355+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
3356+ if (!SWIG_IsOK(ecode2)) {
3357+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","x", 2, argv[0] ));
3358+ }
3359+ arg2 = (float)(val2);
3360+ if (arg1) (arg1)->x = arg2;
3361+ return Qnil;
3362+fail:
3363+ return Qnil;
3364+}
3365+
3366+
3367+SWIGINTERN VALUE
3368+_wrap_Quat_x_get(int argc, VALUE *argv, VALUE self) {
3369+ Quat *arg1 = (Quat *) 0 ;
3370+ void *argp1 = 0 ;
3371+ int res1 = 0 ;
3372+ float result;
3373+ VALUE vresult = Qnil;
3374+
3375+ if ((argc < 0) || (argc > 0)) {
3376+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3377+ }
3378+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Quat, 0 | 0 );
3379+ if (!SWIG_IsOK(res1)) {
3380+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat *","x", 1, self ));
3381+ }
3382+ arg1 = (Quat *)(argp1);
3383+ result = (float) ((arg1)->x);
3384+ vresult = SWIG_From_float((float)(result));
3385+ return vresult;
3386+fail:
3387+ return Qnil;
3388+}
3389+
3390+
3391+SWIGINTERN VALUE
3392+_wrap_Quat_y_set(int argc, VALUE *argv, VALUE self) {
3393+ Quat *arg1 = (Quat *) 0 ;
3394+ float arg2 ;
3395+ void *argp1 = 0 ;
3396+ int res1 = 0 ;
3397+ float val2 ;
3398+ int ecode2 = 0 ;
3399+
3400+ if ((argc < 1) || (argc > 1)) {
3401+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3402+ }
3403+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Quat, 0 | 0 );
3404+ if (!SWIG_IsOK(res1)) {
3405+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat *","y", 1, self ));
3406+ }
3407+ arg1 = (Quat *)(argp1);
3408+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
3409+ if (!SWIG_IsOK(ecode2)) {
3410+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","y", 2, argv[0] ));
3411+ }
3412+ arg2 = (float)(val2);
3413+ if (arg1) (arg1)->y = arg2;
3414+ return Qnil;
3415+fail:
3416+ return Qnil;
3417+}
3418+
3419+
3420+SWIGINTERN VALUE
3421+_wrap_Quat_y_get(int argc, VALUE *argv, VALUE self) {
3422+ Quat *arg1 = (Quat *) 0 ;
3423+ void *argp1 = 0 ;
3424+ int res1 = 0 ;
3425+ float result;
3426+ VALUE vresult = Qnil;
3427+
3428+ if ((argc < 0) || (argc > 0)) {
3429+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3430+ }
3431+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Quat, 0 | 0 );
3432+ if (!SWIG_IsOK(res1)) {
3433+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat *","y", 1, self ));
3434+ }
3435+ arg1 = (Quat *)(argp1);
3436+ result = (float) ((arg1)->y);
3437+ vresult = SWIG_From_float((float)(result));
3438+ return vresult;
3439+fail:
3440+ return Qnil;
3441+}
3442+
3443+
3444+SWIGINTERN VALUE
3445+_wrap_Quat_z_set(int argc, VALUE *argv, VALUE self) {
3446+ Quat *arg1 = (Quat *) 0 ;
3447+ float arg2 ;
3448+ void *argp1 = 0 ;
3449+ int res1 = 0 ;
3450+ float val2 ;
3451+ int ecode2 = 0 ;
3452+
3453+ if ((argc < 1) || (argc > 1)) {
3454+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3455+ }
3456+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Quat, 0 | 0 );
3457+ if (!SWIG_IsOK(res1)) {
3458+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat *","z", 1, self ));
3459+ }
3460+ arg1 = (Quat *)(argp1);
3461+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
3462+ if (!SWIG_IsOK(ecode2)) {
3463+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","z", 2, argv[0] ));
3464+ }
3465+ arg2 = (float)(val2);
3466+ if (arg1) (arg1)->z = arg2;
3467+ return Qnil;
3468+fail:
3469+ return Qnil;
3470+}
3471+
3472+
3473+SWIGINTERN VALUE
3474+_wrap_Quat_z_get(int argc, VALUE *argv, VALUE self) {
3475+ Quat *arg1 = (Quat *) 0 ;
3476+ void *argp1 = 0 ;
3477+ int res1 = 0 ;
3478+ float result;
3479+ VALUE vresult = Qnil;
3480+
3481+ if ((argc < 0) || (argc > 0)) {
3482+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3483+ }
3484+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Quat, 0 | 0 );
3485+ if (!SWIG_IsOK(res1)) {
3486+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat *","z", 1, self ));
3487+ }
3488+ arg1 = (Quat *)(argp1);
3489+ result = (float) ((arg1)->z);
3490+ vresult = SWIG_From_float((float)(result));
3491+ return vresult;
3492+fail:
3493+ return Qnil;
3494+}
3495+
3496+
3497+SWIGINTERN VALUE
3498+_wrap_Quat_w_set(int argc, VALUE *argv, VALUE self) {
3499+ Quat *arg1 = (Quat *) 0 ;
3500+ float arg2 ;
3501+ void *argp1 = 0 ;
3502+ int res1 = 0 ;
3503+ float val2 ;
3504+ int ecode2 = 0 ;
3505+
3506+ if ((argc < 1) || (argc > 1)) {
3507+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3508+ }
3509+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Quat, 0 | 0 );
3510+ if (!SWIG_IsOK(res1)) {
3511+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat *","w", 1, self ));
3512+ }
3513+ arg1 = (Quat *)(argp1);
3514+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
3515+ if (!SWIG_IsOK(ecode2)) {
3516+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","w", 2, argv[0] ));
3517+ }
3518+ arg2 = (float)(val2);
3519+ if (arg1) (arg1)->w = arg2;
3520+ return Qnil;
3521+fail:
3522+ return Qnil;
3523+}
3524+
3525+
3526+SWIGINTERN VALUE
3527+_wrap_Quat_w_get(int argc, VALUE *argv, VALUE self) {
3528+ Quat *arg1 = (Quat *) 0 ;
3529+ void *argp1 = 0 ;
3530+ int res1 = 0 ;
3531+ float result;
3532+ VALUE vresult = Qnil;
3533+
3534+ if ((argc < 0) || (argc > 0)) {
3535+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3536+ }
3537+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Quat, 0 | 0 );
3538+ if (!SWIG_IsOK(res1)) {
3539+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat *","w", 1, self ));
3540+ }
3541+ arg1 = (Quat *)(argp1);
3542+ result = (float) ((arg1)->w);
3543+ vresult = SWIG_From_float((float)(result));
3544+ return vresult;
3545+fail:
3546+ return Qnil;
3547+}
3548+
3549+
3550+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
3551+SWIGINTERN VALUE
3552+_wrap_Quat_allocate(VALUE self) {
3553+#else
3554+ SWIGINTERN VALUE
3555+ _wrap_Quat_allocate(int argc, VALUE *argv, VALUE self) {
3556+#endif
3557+
3558+
3559+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_Quat);
3560+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
3561+ rb_obj_call_init(vresult, argc, argv);
3562+#endif
3563+ return vresult;
3564+ }
3565+
3566+
3567+SWIGINTERN VALUE
3568+_wrap_new_Quat(int argc, VALUE *argv, VALUE self) {
3569+ Quat *result = 0 ;
3570+
3571+ if ((argc < 0) || (argc > 0)) {
3572+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3573+ }
3574+ result = (Quat *)calloc(1, sizeof(Quat));
3575+ DATA_PTR(self) = result;
3576+ return self;
3577+fail:
3578+ return Qnil;
3579+}
3580+
3581+
3582+SWIGINTERN void
3583+free_Quat(Quat *arg1) {
3584+ free((char *) arg1);
3585+}
3586+
3587+SWIGINTERN VALUE
3588+_wrap_Eul_(int argc, VALUE *argv, VALUE self) {
3589+ float arg1 ;
3590+ float arg2 ;
3591+ float arg3 ;
3592+ int arg4 ;
3593+ float val1 ;
3594+ int ecode1 = 0 ;
3595+ float val2 ;
3596+ int ecode2 = 0 ;
3597+ float val3 ;
3598+ int ecode3 = 0 ;
3599+ int val4 ;
3600+ int ecode4 = 0 ;
3601+ EulerAngles result;
3602+ VALUE vresult = Qnil;
3603+
3604+ if ((argc < 4) || (argc > 4)) {
3605+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
3606+ }
3607+ ecode1 = SWIG_AsVal_float(argv[0], &val1);
3608+ if (!SWIG_IsOK(ecode1)) {
3609+ SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "float","Eul_", 1, argv[0] ));
3610+ }
3611+ arg1 = (float)(val1);
3612+ ecode2 = SWIG_AsVal_float(argv[1], &val2);
3613+ if (!SWIG_IsOK(ecode2)) {
3614+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","Eul_", 2, argv[1] ));
3615+ }
3616+ arg2 = (float)(val2);
3617+ ecode3 = SWIG_AsVal_float(argv[2], &val3);
3618+ if (!SWIG_IsOK(ecode3)) {
3619+ SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","Eul_", 3, argv[2] ));
3620+ }
3621+ arg3 = (float)(val3);
3622+ ecode4 = SWIG_AsVal_int(argv[3], &val4);
3623+ if (!SWIG_IsOK(ecode4)) {
3624+ SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Eul_", 4, argv[3] ));
3625+ }
3626+ arg4 = (int)(val4);
3627+ result = Eul_(arg1,arg2,arg3,arg4);
3628+ vresult = SWIG_NewPointerObj((EulerAngles *)memcpy((EulerAngles *)malloc(sizeof(EulerAngles)),&result,sizeof(EulerAngles)), SWIGTYPE_p_Quat, SWIG_POINTER_OWN | 0 );
3629+ return vresult;
3630+fail:
3631+ return Qnil;
3632+}
3633+
3634+
3635+SWIGINTERN VALUE
3636+_wrap_Eul_ToQuat(int argc, VALUE *argv, VALUE self) {
3637+ EulerAngles arg1 ;
3638+ void *argp1 ;
3639+ int res1 = 0 ;
3640+ Quat result;
3641+ VALUE vresult = Qnil;
3642+
3643+ if ((argc < 1) || (argc > 1)) {
3644+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3645+ }
3646+ {
3647+ res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Quat, 0 );
3648+ if (!SWIG_IsOK(res1)) {
3649+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngles","Eul_ToQuat", 1, argv[0] ));
3650+ }
3651+ if (!argp1) {
3652+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "EulerAngles","Eul_ToQuat", 1, argv[0]));
3653+ } else {
3654+ arg1 = *((EulerAngles *)(argp1));
3655+ }
3656+ }
3657+ result = Eul_ToQuat(arg1);
3658+ vresult = SWIG_NewPointerObj((Quat *)memcpy((Quat *)malloc(sizeof(Quat)),&result,sizeof(Quat)), SWIGTYPE_p_Quat, SWIG_POINTER_OWN | 0 );
3659+ return vresult;
3660+fail:
3661+ return Qnil;
3662+}
3663+
3664+
3665+SWIGINTERN VALUE
3666+_wrap_Eul_ToHMatrix(int argc, VALUE *argv, VALUE self) {
3667+ EulerAngles arg1 ;
3668+ matrix3DParaTypeReal (*arg2)[4] ;
3669+ void *argp1 ;
3670+ int res1 = 0 ;
3671+ void *argp2 = 0 ;
3672+ int res2 = 0 ;
3673+
3674+ if ((argc < 2) || (argc > 2)) {
3675+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3676+ }
3677+ {
3678+ res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Quat, 0 );
3679+ if (!SWIG_IsOK(res1)) {
3680+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "EulerAngles","Eul_ToHMatrix", 1, argv[0] ));
3681+ }
3682+ if (!argp1) {
3683+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "EulerAngles","Eul_ToHMatrix", 1, argv[0]));
3684+ } else {
3685+ arg1 = *((EulerAngles *)(argp1));
3686+ }
3687+ }
3688+ res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_a_4__float, 0 | 0 );
3689+ if (!SWIG_IsOK(res2)) {
3690+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float [4][4]","Eul_ToHMatrix", 2, argv[1] ));
3691+ }
3692+ arg2 = (float (*)[4])(argp2);
3693+ Eul_ToHMatrix(arg1,(float (*)[4])arg2);
3694+ return Qnil;
3695+fail:
3696+ return Qnil;
3697+}
3698+
3699+
3700+SWIGINTERN VALUE
3701+_wrap_Eul_FromHMatrix(int argc, VALUE *argv, VALUE self) {
3702+ matrix3DParaTypeReal (*arg1)[4] ;
3703+ int arg2 ;
3704+ void *argp1 = 0 ;
3705+ int res1 = 0 ;
3706+ int val2 ;
3707+ int ecode2 = 0 ;
3708+ EulerAngles result;
3709+ VALUE vresult = Qnil;
3710+
3711+ if ((argc < 2) || (argc > 2)) {
3712+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3713+ }
3714+ res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_a_4__float, 0 | 0 );
3715+ if (!SWIG_IsOK(res1)) {
3716+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float [4][4]","Eul_FromHMatrix", 1, argv[0] ));
3717+ }
3718+ arg1 = (float (*)[4])(argp1);
3719+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3720+ if (!SWIG_IsOK(ecode2)) {
3721+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Eul_FromHMatrix", 2, argv[1] ));
3722+ }
3723+ arg2 = (int)(val2);
3724+ result = Eul_FromHMatrix((float (*)[4])arg1,arg2);
3725+ vresult = SWIG_NewPointerObj((EulerAngles *)memcpy((EulerAngles *)malloc(sizeof(EulerAngles)),&result,sizeof(EulerAngles)), SWIGTYPE_p_Quat, SWIG_POINTER_OWN | 0 );
3726+ return vresult;
3727+fail:
3728+ return Qnil;
3729+}
3730+
3731+
3732+SWIGINTERN VALUE
3733+_wrap_Eul_FromQuat(int argc, VALUE *argv, VALUE self) {
3734+ Quat arg1 ;
3735+ int arg2 ;
3736+ void *argp1 ;
3737+ int res1 = 0 ;
3738+ int val2 ;
3739+ int ecode2 = 0 ;
3740+ EulerAngles result;
3741+ VALUE vresult = Qnil;
3742+
3743+ if ((argc < 2) || (argc > 2)) {
3744+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
3745+ }
3746+ {
3747+ res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Quat, 0 );
3748+ if (!SWIG_IsOK(res1)) {
3749+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Quat","Eul_FromQuat", 1, argv[0] ));
3750+ }
3751+ if (!argp1) {
3752+ SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Quat","Eul_FromQuat", 1, argv[0]));
3753+ } else {
3754+ arg1 = *((Quat *)(argp1));
3755+ }
3756+ }
3757+ ecode2 = SWIG_AsVal_int(argv[1], &val2);
3758+ if (!SWIG_IsOK(ecode2)) {
3759+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Eul_FromQuat", 2, argv[1] ));
3760+ }
3761+ arg2 = (int)(val2);
3762+ result = Eul_FromQuat(arg1,arg2);
3763+ vresult = SWIG_NewPointerObj((EulerAngles *)memcpy((EulerAngles *)malloc(sizeof(EulerAngles)),&result,sizeof(EulerAngles)), SWIGTYPE_p_Quat, SWIG_POINTER_OWN | 0 );
3764+ return vresult;
3765+fail:
3766+ return Qnil;
3767+}
3768+
3769+
3770+SWIGINTERN VALUE
3771+_wrap_mrcImageGeneralTypeList_get(VALUE self) {
3772+ VALUE _val;
3773+
3774+ _val = SWIG_NewPointerObj(SWIG_as_voidptr(mrcImageGeneralTypeList), SWIGTYPE_p_p_char, 0 );
3775+ return _val;
3776+}
3777+
3778+
3779+SWIGINTERN VALUE
3780+_wrap_mrcImageGeneralTypeList_set(VALUE self, VALUE _val) {
3781+ SWIG_exception_fail(SWIG_ArgError(SWIG_AttributeError), "in variable '""read-only mrcImageGeneralTypeList""' of type '""char *[]""'");
3782+ return _val;
3783+fail:
3784+ return Qnil;
3785+}
3786+
3787+
3788+swig_class SwigClassMRC_Status_t;
3789+
3790+SWIGINTERN VALUE
3791+_wrap_MRC_Status_t_all_set(int argc, VALUE *argv, VALUE self) {
3792+ MRC_Status_t *arg1 = (MRC_Status_t *) 0 ;
3793+ mrcStatusType arg2 ;
3794+ void *argp1 = 0 ;
3795+ int res1 = 0 ;
3796+ unsigned int val2 ;
3797+ int ecode2 = 0 ;
3798+
3799+ if ((argc < 1) || (argc > 1)) {
3800+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3801+ }
3802+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t, 0 | 0 );
3803+ if (!SWIG_IsOK(res1)) {
3804+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t *","all", 1, self ));
3805+ }
3806+ arg1 = (MRC_Status_t *)(argp1);
3807+ ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
3808+ if (!SWIG_IsOK(ecode2)) {
3809+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcStatusType","all", 2, argv[0] ));
3810+ }
3811+ arg2 = (mrcStatusType)(val2);
3812+ if (arg1) (arg1)->all = arg2;
3813+ return Qnil;
3814+fail:
3815+ return Qnil;
3816+}
3817+
3818+
3819+SWIGINTERN VALUE
3820+_wrap_MRC_Status_t_all_get(int argc, VALUE *argv, VALUE self) {
3821+ MRC_Status_t *arg1 = (MRC_Status_t *) 0 ;
3822+ void *argp1 = 0 ;
3823+ int res1 = 0 ;
3824+ mrcStatusType result;
3825+ VALUE vresult = Qnil;
3826+
3827+ if ((argc < 0) || (argc > 0)) {
3828+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3829+ }
3830+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t, 0 | 0 );
3831+ if (!SWIG_IsOK(res1)) {
3832+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t *","all", 1, self ));
3833+ }
3834+ arg1 = (MRC_Status_t *)(argp1);
3835+ result = (mrcStatusType) ((arg1)->all);
3836+ vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
3837+ return vresult;
3838+fail:
3839+ return Qnil;
3840+}
3841+
3842+
3843+SWIGINTERN VALUE
3844+_wrap_MRC_Status_t_status_get(int argc, VALUE *argv, VALUE self) {
3845+ MRC_Status_t *arg1 = (MRC_Status_t *) 0 ;
3846+ void *argp1 = 0 ;
3847+ int res1 = 0 ;
3848+ MRC_Status_t_status *result = 0 ;
3849+ VALUE vresult = Qnil;
3850+
3851+ if ((argc < 0) || (argc > 0)) {
3852+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3853+ }
3854+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t, 0 | 0 );
3855+ if (!SWIG_IsOK(res1)) {
3856+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t *","status", 1, self ));
3857+ }
3858+ arg1 = (MRC_Status_t *)(argp1);
3859+ result = (MRC_Status_t_status *)& ((arg1)->status);
3860+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_MRC_Status_t_status, 0 | 0 );
3861+ return vresult;
3862+fail:
3863+ return Qnil;
3864+}
3865+
3866+
3867+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
3868+SWIGINTERN VALUE
3869+_wrap_MRC_Status_t_allocate(VALUE self) {
3870+#else
3871+ SWIGINTERN VALUE
3872+ _wrap_MRC_Status_t_allocate(int argc, VALUE *argv, VALUE self) {
3873+#endif
3874+
3875+
3876+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_MRC_Status_t);
3877+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
3878+ rb_obj_call_init(vresult, argc, argv);
3879+#endif
3880+ return vresult;
3881+ }
3882+
3883+
3884+SWIGINTERN VALUE
3885+_wrap_new_MRC_Status_t(int argc, VALUE *argv, VALUE self) {
3886+ MRC_Status_t *result = 0 ;
3887+
3888+ if ((argc < 0) || (argc > 0)) {
3889+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3890+ }
3891+ result = (MRC_Status_t *)calloc(1, sizeof(MRC_Status_t));
3892+ DATA_PTR(self) = result;
3893+ return self;
3894+fail:
3895+ return Qnil;
3896+}
3897+
3898+
3899+SWIGINTERN void
3900+free_MRC_Status_t(MRC_Status_t *arg1) {
3901+ free((char *) arg1);
3902+}
3903+
3904+swig_class SwigClassMRC_Status_t_status;
3905+
3906+SWIGINTERN VALUE
3907+_wrap_MRC_Status_t_status_detail_set(int argc, VALUE *argv, VALUE self) {
3908+ MRC_Status_t_status *arg1 = (MRC_Status_t_status *) 0 ;
3909+ short arg2 ;
3910+ void *argp1 = 0 ;
3911+ int res1 = 0 ;
3912+ short val2 ;
3913+ int ecode2 = 0 ;
3914+
3915+ if ((argc < 1) || (argc > 1)) {
3916+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3917+ }
3918+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t_status, 0 | 0 );
3919+ if (!SWIG_IsOK(res1)) {
3920+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t_status *","detail", 1, self ));
3921+ }
3922+ arg1 = (MRC_Status_t_status *)(argp1);
3923+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
3924+ if (!SWIG_IsOK(ecode2)) {
3925+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","detail", 2, argv[0] ));
3926+ }
3927+ arg2 = (short)(val2);
3928+ if (arg1) (arg1)->detail = arg2;
3929+ return Qnil;
3930+fail:
3931+ return Qnil;
3932+}
3933+
3934+
3935+SWIGINTERN VALUE
3936+_wrap_MRC_Status_t_status_detail_get(int argc, VALUE *argv, VALUE self) {
3937+ MRC_Status_t_status *arg1 = (MRC_Status_t_status *) 0 ;
3938+ void *argp1 = 0 ;
3939+ int res1 = 0 ;
3940+ short result;
3941+ VALUE vresult = Qnil;
3942+
3943+ if ((argc < 0) || (argc > 0)) {
3944+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3945+ }
3946+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t_status, 0 | 0 );
3947+ if (!SWIG_IsOK(res1)) {
3948+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t_status *","detail", 1, self ));
3949+ }
3950+ arg1 = (MRC_Status_t_status *)(argp1);
3951+ result = (short) ((arg1)->detail);
3952+ vresult = SWIG_From_short((short)(result));
3953+ return vresult;
3954+fail:
3955+ return Qnil;
3956+}
3957+
3958+
3959+SWIGINTERN VALUE
3960+_wrap_MRC_Status_t_status_category_set(int argc, VALUE *argv, VALUE self) {
3961+ MRC_Status_t_status *arg1 = (MRC_Status_t_status *) 0 ;
3962+ unsigned char arg2 ;
3963+ void *argp1 = 0 ;
3964+ int res1 = 0 ;
3965+ unsigned char val2 ;
3966+ int ecode2 = 0 ;
3967+
3968+ if ((argc < 1) || (argc > 1)) {
3969+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
3970+ }
3971+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t_status, 0 | 0 );
3972+ if (!SWIG_IsOK(res1)) {
3973+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t_status *","category", 1, self ));
3974+ }
3975+ arg1 = (MRC_Status_t_status *)(argp1);
3976+ ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
3977+ if (!SWIG_IsOK(ecode2)) {
3978+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","category", 2, argv[0] ));
3979+ }
3980+ arg2 = (unsigned char)(val2);
3981+ if (arg1) (arg1)->category = arg2;
3982+ return Qnil;
3983+fail:
3984+ return Qnil;
3985+}
3986+
3987+
3988+SWIGINTERN VALUE
3989+_wrap_MRC_Status_t_status_category_get(int argc, VALUE *argv, VALUE self) {
3990+ MRC_Status_t_status *arg1 = (MRC_Status_t_status *) 0 ;
3991+ void *argp1 = 0 ;
3992+ int res1 = 0 ;
3993+ unsigned char result;
3994+ VALUE vresult = Qnil;
3995+
3996+ if ((argc < 0) || (argc > 0)) {
3997+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
3998+ }
3999+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t_status, 0 | 0 );
4000+ if (!SWIG_IsOK(res1)) {
4001+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t_status *","category", 1, self ));
4002+ }
4003+ arg1 = (MRC_Status_t_status *)(argp1);
4004+ result = (unsigned char) ((arg1)->category);
4005+ vresult = SWIG_From_unsigned_SS_char((unsigned char)(result));
4006+ return vresult;
4007+fail:
4008+ return Qnil;
4009+}
4010+
4011+
4012+SWIGINTERN VALUE
4013+_wrap_MRC_Status_t_status_level_set(int argc, VALUE *argv, VALUE self) {
4014+ MRC_Status_t_status *arg1 = (MRC_Status_t_status *) 0 ;
4015+ unsigned char arg2 ;
4016+ void *argp1 = 0 ;
4017+ int res1 = 0 ;
4018+ unsigned char val2 ;
4019+ int ecode2 = 0 ;
4020+
4021+ if ((argc < 1) || (argc > 1)) {
4022+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4023+ }
4024+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t_status, 0 | 0 );
4025+ if (!SWIG_IsOK(res1)) {
4026+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t_status *","level", 1, self ));
4027+ }
4028+ arg1 = (MRC_Status_t_status *)(argp1);
4029+ ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
4030+ if (!SWIG_IsOK(ecode2)) {
4031+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned char","level", 2, argv[0] ));
4032+ }
4033+ arg2 = (unsigned char)(val2);
4034+ if (arg1) (arg1)->level = arg2;
4035+ return Qnil;
4036+fail:
4037+ return Qnil;
4038+}
4039+
4040+
4041+SWIGINTERN VALUE
4042+_wrap_MRC_Status_t_status_level_get(int argc, VALUE *argv, VALUE self) {
4043+ MRC_Status_t_status *arg1 = (MRC_Status_t_status *) 0 ;
4044+ void *argp1 = 0 ;
4045+ int res1 = 0 ;
4046+ unsigned char result;
4047+ VALUE vresult = Qnil;
4048+
4049+ if ((argc < 0) || (argc > 0)) {
4050+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4051+ }
4052+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_MRC_Status_t_status, 0 | 0 );
4053+ if (!SWIG_IsOK(res1)) {
4054+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "MRC_Status_t_status *","level", 1, self ));
4055+ }
4056+ arg1 = (MRC_Status_t_status *)(argp1);
4057+ result = (unsigned char) ((arg1)->level);
4058+ vresult = SWIG_From_unsigned_SS_char((unsigned char)(result));
4059+ return vresult;
4060+fail:
4061+ return Qnil;
4062+}
4063+
4064+
4065+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
4066+SWIGINTERN VALUE
4067+_wrap_MRC_Status_t_status_allocate(VALUE self) {
4068+#else
4069+ SWIGINTERN VALUE
4070+ _wrap_MRC_Status_t_status_allocate(int argc, VALUE *argv, VALUE self) {
4071+#endif
4072+
4073+
4074+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_MRC_Status_t_status);
4075+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
4076+ rb_obj_call_init(vresult, argc, argv);
4077+#endif
4078+ return vresult;
4079+ }
4080+
4081+
4082+SWIGINTERN VALUE
4083+_wrap_new_MRC_Status_t_status(int argc, VALUE *argv, VALUE self) {
4084+ MRC_Status_t_status *result = 0 ;
4085+
4086+ if ((argc < 0) || (argc > 0)) {
4087+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4088+ }
4089+ result = (MRC_Status_t_status *)calloc(1, sizeof(MRC_Status_t_status));
4090+ DATA_PTR(self) = result;
4091+ return self;
4092+fail:
4093+ return Qnil;
4094+}
4095+
4096+
4097+SWIGINTERN void
4098+free_MRC_Status_t_status(MRC_Status_t_status *arg1) {
4099+ free((char *) arg1);
4100+}
4101+
4102+swig_class SwigClassMrcImageParaTypeIntegerCoord;
4103+
4104+SWIGINTERN VALUE
4105+_wrap_mrcImageParaTypeIntegerCoord_x_set(int argc, VALUE *argv, VALUE self) {
4106+ mrcImageParaTypeIntegerCoord *arg1 = (mrcImageParaTypeIntegerCoord *) 0 ;
4107+ mrcImageParaTypeInteger arg2 ;
4108+ void *argp1 = 0 ;
4109+ int res1 = 0 ;
4110+ int val2 ;
4111+ int ecode2 = 0 ;
4112+
4113+ if ((argc < 1) || (argc > 1)) {
4114+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4115+ }
4116+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4117+ if (!SWIG_IsOK(res1)) {
4118+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","x", 1, self ));
4119+ }
4120+ arg1 = (mrcImageParaTypeIntegerCoord *)(argp1);
4121+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
4122+ if (!SWIG_IsOK(ecode2)) {
4123+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","x", 2, argv[0] ));
4124+ }
4125+ arg2 = (mrcImageParaTypeInteger)(val2);
4126+ if (arg1) (arg1)->x = arg2;
4127+ return Qnil;
4128+fail:
4129+ return Qnil;
4130+}
4131+
4132+
4133+SWIGINTERN VALUE
4134+_wrap_mrcImageParaTypeIntegerCoord_x_get(int argc, VALUE *argv, VALUE self) {
4135+ mrcImageParaTypeIntegerCoord *arg1 = (mrcImageParaTypeIntegerCoord *) 0 ;
4136+ void *argp1 = 0 ;
4137+ int res1 = 0 ;
4138+ mrcImageParaTypeInteger result;
4139+ VALUE vresult = Qnil;
4140+
4141+ if ((argc < 0) || (argc > 0)) {
4142+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4143+ }
4144+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4145+ if (!SWIG_IsOK(res1)) {
4146+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","x", 1, self ));
4147+ }
4148+ arg1 = (mrcImageParaTypeIntegerCoord *)(argp1);
4149+ result = (mrcImageParaTypeInteger) ((arg1)->x);
4150+ vresult = SWIG_From_int((int)(result));
4151+ return vresult;
4152+fail:
4153+ return Qnil;
4154+}
4155+
4156+
4157+SWIGINTERN VALUE
4158+_wrap_mrcImageParaTypeIntegerCoord_y_set(int argc, VALUE *argv, VALUE self) {
4159+ mrcImageParaTypeIntegerCoord *arg1 = (mrcImageParaTypeIntegerCoord *) 0 ;
4160+ mrcImageParaTypeInteger arg2 ;
4161+ void *argp1 = 0 ;
4162+ int res1 = 0 ;
4163+ int val2 ;
4164+ int ecode2 = 0 ;
4165+
4166+ if ((argc < 1) || (argc > 1)) {
4167+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4168+ }
4169+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4170+ if (!SWIG_IsOK(res1)) {
4171+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","y", 1, self ));
4172+ }
4173+ arg1 = (mrcImageParaTypeIntegerCoord *)(argp1);
4174+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
4175+ if (!SWIG_IsOK(ecode2)) {
4176+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","y", 2, argv[0] ));
4177+ }
4178+ arg2 = (mrcImageParaTypeInteger)(val2);
4179+ if (arg1) (arg1)->y = arg2;
4180+ return Qnil;
4181+fail:
4182+ return Qnil;
4183+}
4184+
4185+
4186+SWIGINTERN VALUE
4187+_wrap_mrcImageParaTypeIntegerCoord_y_get(int argc, VALUE *argv, VALUE self) {
4188+ mrcImageParaTypeIntegerCoord *arg1 = (mrcImageParaTypeIntegerCoord *) 0 ;
4189+ void *argp1 = 0 ;
4190+ int res1 = 0 ;
4191+ mrcImageParaTypeInteger result;
4192+ VALUE vresult = Qnil;
4193+
4194+ if ((argc < 0) || (argc > 0)) {
4195+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4196+ }
4197+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4198+ if (!SWIG_IsOK(res1)) {
4199+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","y", 1, self ));
4200+ }
4201+ arg1 = (mrcImageParaTypeIntegerCoord *)(argp1);
4202+ result = (mrcImageParaTypeInteger) ((arg1)->y);
4203+ vresult = SWIG_From_int((int)(result));
4204+ return vresult;
4205+fail:
4206+ return Qnil;
4207+}
4208+
4209+
4210+SWIGINTERN VALUE
4211+_wrap_mrcImageParaTypeIntegerCoord_z_set(int argc, VALUE *argv, VALUE self) {
4212+ mrcImageParaTypeIntegerCoord *arg1 = (mrcImageParaTypeIntegerCoord *) 0 ;
4213+ mrcImageParaTypeInteger arg2 ;
4214+ void *argp1 = 0 ;
4215+ int res1 = 0 ;
4216+ int val2 ;
4217+ int ecode2 = 0 ;
4218+
4219+ if ((argc < 1) || (argc > 1)) {
4220+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4221+ }
4222+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4223+ if (!SWIG_IsOK(res1)) {
4224+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","z", 1, self ));
4225+ }
4226+ arg1 = (mrcImageParaTypeIntegerCoord *)(argp1);
4227+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
4228+ if (!SWIG_IsOK(ecode2)) {
4229+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","z", 2, argv[0] ));
4230+ }
4231+ arg2 = (mrcImageParaTypeInteger)(val2);
4232+ if (arg1) (arg1)->z = arg2;
4233+ return Qnil;
4234+fail:
4235+ return Qnil;
4236+}
4237+
4238+
4239+SWIGINTERN VALUE
4240+_wrap_mrcImageParaTypeIntegerCoord_z_get(int argc, VALUE *argv, VALUE self) {
4241+ mrcImageParaTypeIntegerCoord *arg1 = (mrcImageParaTypeIntegerCoord *) 0 ;
4242+ void *argp1 = 0 ;
4243+ int res1 = 0 ;
4244+ mrcImageParaTypeInteger result;
4245+ VALUE vresult = Qnil;
4246+
4247+ if ((argc < 0) || (argc > 0)) {
4248+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4249+ }
4250+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4251+ if (!SWIG_IsOK(res1)) {
4252+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","z", 1, self ));
4253+ }
4254+ arg1 = (mrcImageParaTypeIntegerCoord *)(argp1);
4255+ result = (mrcImageParaTypeInteger) ((arg1)->z);
4256+ vresult = SWIG_From_int((int)(result));
4257+ return vresult;
4258+fail:
4259+ return Qnil;
4260+}
4261+
4262+
4263+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
4264+SWIGINTERN VALUE
4265+_wrap_mrcImageParaTypeIntegerCoord_allocate(VALUE self) {
4266+#else
4267+ SWIGINTERN VALUE
4268+ _wrap_mrcImageParaTypeIntegerCoord_allocate(int argc, VALUE *argv, VALUE self) {
4269+#endif
4270+
4271+
4272+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_mrcImageParaTypeIntegerCoord);
4273+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
4274+ rb_obj_call_init(vresult, argc, argv);
4275+#endif
4276+ return vresult;
4277+ }
4278+
4279+
4280+SWIGINTERN VALUE
4281+_wrap_new_mrcImageParaTypeIntegerCoord(int argc, VALUE *argv, VALUE self) {
4282+ mrcImageParaTypeIntegerCoord *result = 0 ;
4283+
4284+ if ((argc < 0) || (argc > 0)) {
4285+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4286+ }
4287+ result = (mrcImageParaTypeIntegerCoord *)calloc(1, sizeof(mrcImageParaTypeIntegerCoord));
4288+ DATA_PTR(self) = result;
4289+ return self;
4290+fail:
4291+ return Qnil;
4292+}
4293+
4294+
4295+SWIGINTERN void
4296+free_mrcImageParaTypeIntegerCoord(mrcImageParaTypeIntegerCoord *arg1) {
4297+ free((char *) arg1);
4298+}
4299+
4300+swig_class SwigClassMrcImageParaTypeRealCoord;
4301+
4302+SWIGINTERN VALUE
4303+_wrap_mrcImageParaTypeRealCoord_x_set(int argc, VALUE *argv, VALUE self) {
4304+ mrcImageParaTypeRealCoord *arg1 = (mrcImageParaTypeRealCoord *) 0 ;
4305+ mrcImageParaTypeReal arg2 ;
4306+ void *argp1 = 0 ;
4307+ int res1 = 0 ;
4308+ float val2 ;
4309+ int ecode2 = 0 ;
4310+
4311+ if ((argc < 1) || (argc > 1)) {
4312+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4313+ }
4314+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
4315+ if (!SWIG_IsOK(res1)) {
4316+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","x", 1, self ));
4317+ }
4318+ arg1 = (mrcImageParaTypeRealCoord *)(argp1);
4319+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
4320+ if (!SWIG_IsOK(ecode2)) {
4321+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","x", 2, argv[0] ));
4322+ }
4323+ arg2 = (mrcImageParaTypeReal)(val2);
4324+ if (arg1) (arg1)->x = arg2;
4325+ return Qnil;
4326+fail:
4327+ return Qnil;
4328+}
4329+
4330+
4331+SWIGINTERN VALUE
4332+_wrap_mrcImageParaTypeRealCoord_x_get(int argc, VALUE *argv, VALUE self) {
4333+ mrcImageParaTypeRealCoord *arg1 = (mrcImageParaTypeRealCoord *) 0 ;
4334+ void *argp1 = 0 ;
4335+ int res1 = 0 ;
4336+ mrcImageParaTypeReal result;
4337+ VALUE vresult = Qnil;
4338+
4339+ if ((argc < 0) || (argc > 0)) {
4340+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4341+ }
4342+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
4343+ if (!SWIG_IsOK(res1)) {
4344+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","x", 1, self ));
4345+ }
4346+ arg1 = (mrcImageParaTypeRealCoord *)(argp1);
4347+ result = (mrcImageParaTypeReal) ((arg1)->x);
4348+ vresult = SWIG_From_float((float)(result));
4349+ return vresult;
4350+fail:
4351+ return Qnil;
4352+}
4353+
4354+
4355+SWIGINTERN VALUE
4356+_wrap_mrcImageParaTypeRealCoord_y_set(int argc, VALUE *argv, VALUE self) {
4357+ mrcImageParaTypeRealCoord *arg1 = (mrcImageParaTypeRealCoord *) 0 ;
4358+ mrcImageParaTypeReal arg2 ;
4359+ void *argp1 = 0 ;
4360+ int res1 = 0 ;
4361+ float val2 ;
4362+ int ecode2 = 0 ;
4363+
4364+ if ((argc < 1) || (argc > 1)) {
4365+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4366+ }
4367+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
4368+ if (!SWIG_IsOK(res1)) {
4369+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","y", 1, self ));
4370+ }
4371+ arg1 = (mrcImageParaTypeRealCoord *)(argp1);
4372+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
4373+ if (!SWIG_IsOK(ecode2)) {
4374+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","y", 2, argv[0] ));
4375+ }
4376+ arg2 = (mrcImageParaTypeReal)(val2);
4377+ if (arg1) (arg1)->y = arg2;
4378+ return Qnil;
4379+fail:
4380+ return Qnil;
4381+}
4382+
4383+
4384+SWIGINTERN VALUE
4385+_wrap_mrcImageParaTypeRealCoord_y_get(int argc, VALUE *argv, VALUE self) {
4386+ mrcImageParaTypeRealCoord *arg1 = (mrcImageParaTypeRealCoord *) 0 ;
4387+ void *argp1 = 0 ;
4388+ int res1 = 0 ;
4389+ mrcImageParaTypeReal result;
4390+ VALUE vresult = Qnil;
4391+
4392+ if ((argc < 0) || (argc > 0)) {
4393+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4394+ }
4395+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
4396+ if (!SWIG_IsOK(res1)) {
4397+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","y", 1, self ));
4398+ }
4399+ arg1 = (mrcImageParaTypeRealCoord *)(argp1);
4400+ result = (mrcImageParaTypeReal) ((arg1)->y);
4401+ vresult = SWIG_From_float((float)(result));
4402+ return vresult;
4403+fail:
4404+ return Qnil;
4405+}
4406+
4407+
4408+SWIGINTERN VALUE
4409+_wrap_mrcImageParaTypeRealCoord_z_set(int argc, VALUE *argv, VALUE self) {
4410+ mrcImageParaTypeRealCoord *arg1 = (mrcImageParaTypeRealCoord *) 0 ;
4411+ mrcImageParaTypeReal arg2 ;
4412+ void *argp1 = 0 ;
4413+ int res1 = 0 ;
4414+ float val2 ;
4415+ int ecode2 = 0 ;
4416+
4417+ if ((argc < 1) || (argc > 1)) {
4418+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4419+ }
4420+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
4421+ if (!SWIG_IsOK(res1)) {
4422+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","z", 1, self ));
4423+ }
4424+ arg1 = (mrcImageParaTypeRealCoord *)(argp1);
4425+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
4426+ if (!SWIG_IsOK(ecode2)) {
4427+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","z", 2, argv[0] ));
4428+ }
4429+ arg2 = (mrcImageParaTypeReal)(val2);
4430+ if (arg1) (arg1)->z = arg2;
4431+ return Qnil;
4432+fail:
4433+ return Qnil;
4434+}
4435+
4436+
4437+SWIGINTERN VALUE
4438+_wrap_mrcImageParaTypeRealCoord_z_get(int argc, VALUE *argv, VALUE self) {
4439+ mrcImageParaTypeRealCoord *arg1 = (mrcImageParaTypeRealCoord *) 0 ;
4440+ void *argp1 = 0 ;
4441+ int res1 = 0 ;
4442+ mrcImageParaTypeReal result;
4443+ VALUE vresult = Qnil;
4444+
4445+ if ((argc < 0) || (argc > 0)) {
4446+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4447+ }
4448+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
4449+ if (!SWIG_IsOK(res1)) {
4450+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","z", 1, self ));
4451+ }
4452+ arg1 = (mrcImageParaTypeRealCoord *)(argp1);
4453+ result = (mrcImageParaTypeReal) ((arg1)->z);
4454+ vresult = SWIG_From_float((float)(result));
4455+ return vresult;
4456+fail:
4457+ return Qnil;
4458+}
4459+
4460+
4461+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
4462+SWIGINTERN VALUE
4463+_wrap_mrcImageParaTypeRealCoord_allocate(VALUE self) {
4464+#else
4465+ SWIGINTERN VALUE
4466+ _wrap_mrcImageParaTypeRealCoord_allocate(int argc, VALUE *argv, VALUE self) {
4467+#endif
4468+
4469+
4470+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_mrcImageParaTypeRealCoord);
4471+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
4472+ rb_obj_call_init(vresult, argc, argv);
4473+#endif
4474+ return vresult;
4475+ }
4476+
4477+
4478+SWIGINTERN VALUE
4479+_wrap_new_mrcImageParaTypeRealCoord(int argc, VALUE *argv, VALUE self) {
4480+ mrcImageParaTypeRealCoord *result = 0 ;
4481+
4482+ if ((argc < 0) || (argc > 0)) {
4483+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4484+ }
4485+ result = (mrcImageParaTypeRealCoord *)calloc(1, sizeof(mrcImageParaTypeRealCoord));
4486+ DATA_PTR(self) = result;
4487+ return self;
4488+fail:
4489+ return Qnil;
4490+}
4491+
4492+
4493+SWIGINTERN void
4494+free_mrcImageParaTypeRealCoord(mrcImageParaTypeRealCoord *arg1) {
4495+ free((char *) arg1);
4496+}
4497+
4498+swig_class SwigClass_mrcImageHeader;
4499+
4500+SWIGINTERN VALUE
4501+_wrap__mrcImageHeader_N_set(int argc, VALUE *argv, VALUE self) {
4502+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4503+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
4504+ void *argp1 = 0 ;
4505+ int res1 = 0 ;
4506+ void *argp2 = 0 ;
4507+ int res2 = 0 ;
4508+
4509+ if ((argc < 1) || (argc > 1)) {
4510+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4511+ }
4512+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4513+ if (!SWIG_IsOK(res1)) {
4514+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","N", 1, self ));
4515+ }
4516+ arg1 = (_mrcImageHeader *)(argp1);
4517+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4518+ if (!SWIG_IsOK(res2)) {
4519+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","N", 2, argv[0] ));
4520+ }
4521+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
4522+ if (arg1) (arg1)->N = *arg2;
4523+ return Qnil;
4524+fail:
4525+ return Qnil;
4526+}
4527+
4528+
4529+SWIGINTERN VALUE
4530+_wrap__mrcImageHeader_N_get(int argc, VALUE *argv, VALUE self) {
4531+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4532+ void *argp1 = 0 ;
4533+ int res1 = 0 ;
4534+ mrcImageParaTypeIntegerCoord *result = 0 ;
4535+ VALUE vresult = Qnil;
4536+
4537+ if ((argc < 0) || (argc > 0)) {
4538+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4539+ }
4540+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4541+ if (!SWIG_IsOK(res1)) {
4542+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","N", 1, self ));
4543+ }
4544+ arg1 = (_mrcImageHeader *)(argp1);
4545+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->N);
4546+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4547+ return vresult;
4548+fail:
4549+ return Qnil;
4550+}
4551+
4552+
4553+SWIGINTERN VALUE
4554+_wrap__mrcImageHeader_Mode_set(int argc, VALUE *argv, VALUE self) {
4555+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4556+ mrcImageMode arg2 ;
4557+ void *argp1 = 0 ;
4558+ int res1 = 0 ;
4559+ int val2 ;
4560+ int ecode2 = 0 ;
4561+
4562+ if ((argc < 1) || (argc > 1)) {
4563+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4564+ }
4565+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4566+ if (!SWIG_IsOK(res1)) {
4567+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Mode", 1, self ));
4568+ }
4569+ arg1 = (_mrcImageHeader *)(argp1);
4570+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
4571+ if (!SWIG_IsOK(ecode2)) {
4572+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageMode","Mode", 2, argv[0] ));
4573+ }
4574+ arg2 = (mrcImageMode)(val2);
4575+ if (arg1) (arg1)->Mode = arg2;
4576+ return Qnil;
4577+fail:
4578+ return Qnil;
4579+}
4580+
4581+
4582+SWIGINTERN VALUE
4583+_wrap__mrcImageHeader_Mode_get(int argc, VALUE *argv, VALUE self) {
4584+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4585+ void *argp1 = 0 ;
4586+ int res1 = 0 ;
4587+ mrcImageMode result;
4588+ VALUE vresult = Qnil;
4589+
4590+ if ((argc < 0) || (argc > 0)) {
4591+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4592+ }
4593+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4594+ if (!SWIG_IsOK(res1)) {
4595+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Mode", 1, self ));
4596+ }
4597+ arg1 = (_mrcImageHeader *)(argp1);
4598+ result = (mrcImageMode) ((arg1)->Mode);
4599+ vresult = SWIG_From_int((int)(result));
4600+ return vresult;
4601+fail:
4602+ return Qnil;
4603+}
4604+
4605+
4606+SWIGINTERN VALUE
4607+_wrap__mrcImageHeader_StartN_set(int argc, VALUE *argv, VALUE self) {
4608+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4609+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
4610+ void *argp1 = 0 ;
4611+ int res1 = 0 ;
4612+ void *argp2 = 0 ;
4613+ int res2 = 0 ;
4614+
4615+ if ((argc < 1) || (argc > 1)) {
4616+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4617+ }
4618+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4619+ if (!SWIG_IsOK(res1)) {
4620+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","StartN", 1, self ));
4621+ }
4622+ arg1 = (_mrcImageHeader *)(argp1);
4623+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4624+ if (!SWIG_IsOK(res2)) {
4625+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","StartN", 2, argv[0] ));
4626+ }
4627+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
4628+ if (arg1) (arg1)->StartN = *arg2;
4629+ return Qnil;
4630+fail:
4631+ return Qnil;
4632+}
4633+
4634+
4635+SWIGINTERN VALUE
4636+_wrap__mrcImageHeader_StartN_get(int argc, VALUE *argv, VALUE self) {
4637+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4638+ void *argp1 = 0 ;
4639+ int res1 = 0 ;
4640+ mrcImageParaTypeIntegerCoord *result = 0 ;
4641+ VALUE vresult = Qnil;
4642+
4643+ if ((argc < 0) || (argc > 0)) {
4644+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4645+ }
4646+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4647+ if (!SWIG_IsOK(res1)) {
4648+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","StartN", 1, self ));
4649+ }
4650+ arg1 = (_mrcImageHeader *)(argp1);
4651+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->StartN);
4652+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4653+ return vresult;
4654+fail:
4655+ return Qnil;
4656+}
4657+
4658+
4659+SWIGINTERN VALUE
4660+_wrap__mrcImageHeader_M_set(int argc, VALUE *argv, VALUE self) {
4661+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4662+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
4663+ void *argp1 = 0 ;
4664+ int res1 = 0 ;
4665+ void *argp2 = 0 ;
4666+ int res2 = 0 ;
4667+
4668+ if ((argc < 1) || (argc > 1)) {
4669+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4670+ }
4671+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4672+ if (!SWIG_IsOK(res1)) {
4673+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","M", 1, self ));
4674+ }
4675+ arg1 = (_mrcImageHeader *)(argp1);
4676+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4677+ if (!SWIG_IsOK(res2)) {
4678+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","M", 2, argv[0] ));
4679+ }
4680+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
4681+ if (arg1) (arg1)->M = *arg2;
4682+ return Qnil;
4683+fail:
4684+ return Qnil;
4685+}
4686+
4687+
4688+SWIGINTERN VALUE
4689+_wrap__mrcImageHeader_M_get(int argc, VALUE *argv, VALUE self) {
4690+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4691+ void *argp1 = 0 ;
4692+ int res1 = 0 ;
4693+ mrcImageParaTypeIntegerCoord *result = 0 ;
4694+ VALUE vresult = Qnil;
4695+
4696+ if ((argc < 0) || (argc > 0)) {
4697+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4698+ }
4699+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4700+ if (!SWIG_IsOK(res1)) {
4701+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","M", 1, self ));
4702+ }
4703+ arg1 = (_mrcImageHeader *)(argp1);
4704+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->M);
4705+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
4706+ return vresult;
4707+fail:
4708+ return Qnil;
4709+}
4710+
4711+
4712+SWIGINTERN VALUE
4713+_wrap__mrcImageHeader_Length_set(int argc, VALUE *argv, VALUE self) {
4714+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4715+ mrcImageParaTypeRealCoord *arg2 = (mrcImageParaTypeRealCoord *) 0 ;
4716+ void *argp1 = 0 ;
4717+ int res1 = 0 ;
4718+ void *argp2 = 0 ;
4719+ int res2 = 0 ;
4720+
4721+ if ((argc < 1) || (argc > 1)) {
4722+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4723+ }
4724+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4725+ if (!SWIG_IsOK(res1)) {
4726+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Length", 1, self ));
4727+ }
4728+ arg1 = (_mrcImageHeader *)(argp1);
4729+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
4730+ if (!SWIG_IsOK(res2)) {
4731+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","Length", 2, argv[0] ));
4732+ }
4733+ arg2 = (mrcImageParaTypeRealCoord *)(argp2);
4734+ if (arg1) (arg1)->Length = *arg2;
4735+ return Qnil;
4736+fail:
4737+ return Qnil;
4738+}
4739+
4740+
4741+SWIGINTERN VALUE
4742+_wrap__mrcImageHeader_Length_get(int argc, VALUE *argv, VALUE self) {
4743+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4744+ void *argp1 = 0 ;
4745+ int res1 = 0 ;
4746+ mrcImageParaTypeRealCoord *result = 0 ;
4747+ VALUE vresult = Qnil;
4748+
4749+ if ((argc < 0) || (argc > 0)) {
4750+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4751+ }
4752+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4753+ if (!SWIG_IsOK(res1)) {
4754+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Length", 1, self ));
4755+ }
4756+ arg1 = (_mrcImageHeader *)(argp1);
4757+ result = (mrcImageParaTypeRealCoord *)& ((arg1)->Length);
4758+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
4759+ return vresult;
4760+fail:
4761+ return Qnil;
4762+}
4763+
4764+
4765+SWIGINTERN VALUE
4766+_wrap__mrcImageHeader_Alpha_set(int argc, VALUE *argv, VALUE self) {
4767+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4768+ mrcImageParaTypeReal arg2 ;
4769+ void *argp1 = 0 ;
4770+ int res1 = 0 ;
4771+ float val2 ;
4772+ int ecode2 = 0 ;
4773+
4774+ if ((argc < 1) || (argc > 1)) {
4775+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4776+ }
4777+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4778+ if (!SWIG_IsOK(res1)) {
4779+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Alpha", 1, self ));
4780+ }
4781+ arg1 = (_mrcImageHeader *)(argp1);
4782+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
4783+ if (!SWIG_IsOK(ecode2)) {
4784+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Alpha", 2, argv[0] ));
4785+ }
4786+ arg2 = (mrcImageParaTypeReal)(val2);
4787+ if (arg1) (arg1)->Alpha = arg2;
4788+ return Qnil;
4789+fail:
4790+ return Qnil;
4791+}
4792+
4793+
4794+SWIGINTERN VALUE
4795+_wrap__mrcImageHeader_Alpha_get(int argc, VALUE *argv, VALUE self) {
4796+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4797+ void *argp1 = 0 ;
4798+ int res1 = 0 ;
4799+ mrcImageParaTypeReal result;
4800+ VALUE vresult = Qnil;
4801+
4802+ if ((argc < 0) || (argc > 0)) {
4803+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4804+ }
4805+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4806+ if (!SWIG_IsOK(res1)) {
4807+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Alpha", 1, self ));
4808+ }
4809+ arg1 = (_mrcImageHeader *)(argp1);
4810+ result = (mrcImageParaTypeReal) ((arg1)->Alpha);
4811+ vresult = SWIG_From_float((float)(result));
4812+ return vresult;
4813+fail:
4814+ return Qnil;
4815+}
4816+
4817+
4818+SWIGINTERN VALUE
4819+_wrap__mrcImageHeader_Beta_set(int argc, VALUE *argv, VALUE self) {
4820+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4821+ mrcImageParaTypeReal arg2 ;
4822+ void *argp1 = 0 ;
4823+ int res1 = 0 ;
4824+ float val2 ;
4825+ int ecode2 = 0 ;
4826+
4827+ if ((argc < 1) || (argc > 1)) {
4828+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4829+ }
4830+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4831+ if (!SWIG_IsOK(res1)) {
4832+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Beta", 1, self ));
4833+ }
4834+ arg1 = (_mrcImageHeader *)(argp1);
4835+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
4836+ if (!SWIG_IsOK(ecode2)) {
4837+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Beta", 2, argv[0] ));
4838+ }
4839+ arg2 = (mrcImageParaTypeReal)(val2);
4840+ if (arg1) (arg1)->Beta = arg2;
4841+ return Qnil;
4842+fail:
4843+ return Qnil;
4844+}
4845+
4846+
4847+SWIGINTERN VALUE
4848+_wrap__mrcImageHeader_Beta_get(int argc, VALUE *argv, VALUE self) {
4849+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4850+ void *argp1 = 0 ;
4851+ int res1 = 0 ;
4852+ mrcImageParaTypeReal result;
4853+ VALUE vresult = Qnil;
4854+
4855+ if ((argc < 0) || (argc > 0)) {
4856+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4857+ }
4858+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4859+ if (!SWIG_IsOK(res1)) {
4860+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Beta", 1, self ));
4861+ }
4862+ arg1 = (_mrcImageHeader *)(argp1);
4863+ result = (mrcImageParaTypeReal) ((arg1)->Beta);
4864+ vresult = SWIG_From_float((float)(result));
4865+ return vresult;
4866+fail:
4867+ return Qnil;
4868+}
4869+
4870+
4871+SWIGINTERN VALUE
4872+_wrap__mrcImageHeader_Gamma_set(int argc, VALUE *argv, VALUE self) {
4873+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4874+ mrcImageParaTypeReal arg2 ;
4875+ void *argp1 = 0 ;
4876+ int res1 = 0 ;
4877+ float val2 ;
4878+ int ecode2 = 0 ;
4879+
4880+ if ((argc < 1) || (argc > 1)) {
4881+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4882+ }
4883+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4884+ if (!SWIG_IsOK(res1)) {
4885+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Gamma", 1, self ));
4886+ }
4887+ arg1 = (_mrcImageHeader *)(argp1);
4888+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
4889+ if (!SWIG_IsOK(ecode2)) {
4890+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Gamma", 2, argv[0] ));
4891+ }
4892+ arg2 = (mrcImageParaTypeReal)(val2);
4893+ if (arg1) (arg1)->Gamma = arg2;
4894+ return Qnil;
4895+fail:
4896+ return Qnil;
4897+}
4898+
4899+
4900+SWIGINTERN VALUE
4901+_wrap__mrcImageHeader_Gamma_get(int argc, VALUE *argv, VALUE self) {
4902+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4903+ void *argp1 = 0 ;
4904+ int res1 = 0 ;
4905+ mrcImageParaTypeReal result;
4906+ VALUE vresult = Qnil;
4907+
4908+ if ((argc < 0) || (argc > 0)) {
4909+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4910+ }
4911+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4912+ if (!SWIG_IsOK(res1)) {
4913+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Gamma", 1, self ));
4914+ }
4915+ arg1 = (_mrcImageHeader *)(argp1);
4916+ result = (mrcImageParaTypeReal) ((arg1)->Gamma);
4917+ vresult = SWIG_From_float((float)(result));
4918+ return vresult;
4919+fail:
4920+ return Qnil;
4921+}
4922+
4923+
4924+SWIGINTERN VALUE
4925+_wrap__mrcImageHeader_MAPC_set(int argc, VALUE *argv, VALUE self) {
4926+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4927+ mrcImageParaTypeInteger arg2 ;
4928+ void *argp1 = 0 ;
4929+ int res1 = 0 ;
4930+ int val2 ;
4931+ int ecode2 = 0 ;
4932+
4933+ if ((argc < 1) || (argc > 1)) {
4934+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4935+ }
4936+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4937+ if (!SWIG_IsOK(res1)) {
4938+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","MAPC", 1, self ));
4939+ }
4940+ arg1 = (_mrcImageHeader *)(argp1);
4941+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
4942+ if (!SWIG_IsOK(ecode2)) {
4943+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPC", 2, argv[0] ));
4944+ }
4945+ arg2 = (mrcImageParaTypeInteger)(val2);
4946+ if (arg1) (arg1)->MAPC = arg2;
4947+ return Qnil;
4948+fail:
4949+ return Qnil;
4950+}
4951+
4952+
4953+SWIGINTERN VALUE
4954+_wrap__mrcImageHeader_MAPC_get(int argc, VALUE *argv, VALUE self) {
4955+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4956+ void *argp1 = 0 ;
4957+ int res1 = 0 ;
4958+ mrcImageParaTypeInteger result;
4959+ VALUE vresult = Qnil;
4960+
4961+ if ((argc < 0) || (argc > 0)) {
4962+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
4963+ }
4964+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4965+ if (!SWIG_IsOK(res1)) {
4966+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","MAPC", 1, self ));
4967+ }
4968+ arg1 = (_mrcImageHeader *)(argp1);
4969+ result = (mrcImageParaTypeInteger) ((arg1)->MAPC);
4970+ vresult = SWIG_From_int((int)(result));
4971+ return vresult;
4972+fail:
4973+ return Qnil;
4974+}
4975+
4976+
4977+SWIGINTERN VALUE
4978+_wrap__mrcImageHeader_MAPR_set(int argc, VALUE *argv, VALUE self) {
4979+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
4980+ mrcImageParaTypeInteger arg2 ;
4981+ void *argp1 = 0 ;
4982+ int res1 = 0 ;
4983+ int val2 ;
4984+ int ecode2 = 0 ;
4985+
4986+ if ((argc < 1) || (argc > 1)) {
4987+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
4988+ }
4989+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
4990+ if (!SWIG_IsOK(res1)) {
4991+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","MAPR", 1, self ));
4992+ }
4993+ arg1 = (_mrcImageHeader *)(argp1);
4994+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
4995+ if (!SWIG_IsOK(ecode2)) {
4996+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPR", 2, argv[0] ));
4997+ }
4998+ arg2 = (mrcImageParaTypeInteger)(val2);
4999+ if (arg1) (arg1)->MAPR = arg2;
5000+ return Qnil;
5001+fail:
5002+ return Qnil;
5003+}
5004+
5005+
5006+SWIGINTERN VALUE
5007+_wrap__mrcImageHeader_MAPR_get(int argc, VALUE *argv, VALUE self) {
5008+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5009+ void *argp1 = 0 ;
5010+ int res1 = 0 ;
5011+ mrcImageParaTypeInteger result;
5012+ VALUE vresult = Qnil;
5013+
5014+ if ((argc < 0) || (argc > 0)) {
5015+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5016+ }
5017+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5018+ if (!SWIG_IsOK(res1)) {
5019+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","MAPR", 1, self ));
5020+ }
5021+ arg1 = (_mrcImageHeader *)(argp1);
5022+ result = (mrcImageParaTypeInteger) ((arg1)->MAPR);
5023+ vresult = SWIG_From_int((int)(result));
5024+ return vresult;
5025+fail:
5026+ return Qnil;
5027+}
5028+
5029+
5030+SWIGINTERN VALUE
5031+_wrap__mrcImageHeader_MAPS_set(int argc, VALUE *argv, VALUE self) {
5032+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5033+ mrcImageParaTypeInteger arg2 ;
5034+ void *argp1 = 0 ;
5035+ int res1 = 0 ;
5036+ int val2 ;
5037+ int ecode2 = 0 ;
5038+
5039+ if ((argc < 1) || (argc > 1)) {
5040+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5041+ }
5042+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5043+ if (!SWIG_IsOK(res1)) {
5044+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","MAPS", 1, self ));
5045+ }
5046+ arg1 = (_mrcImageHeader *)(argp1);
5047+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
5048+ if (!SWIG_IsOK(ecode2)) {
5049+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPS", 2, argv[0] ));
5050+ }
5051+ arg2 = (mrcImageParaTypeInteger)(val2);
5052+ if (arg1) (arg1)->MAPS = arg2;
5053+ return Qnil;
5054+fail:
5055+ return Qnil;
5056+}
5057+
5058+
5059+SWIGINTERN VALUE
5060+_wrap__mrcImageHeader_MAPS_get(int argc, VALUE *argv, VALUE self) {
5061+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5062+ void *argp1 = 0 ;
5063+ int res1 = 0 ;
5064+ mrcImageParaTypeInteger result;
5065+ VALUE vresult = Qnil;
5066+
5067+ if ((argc < 0) || (argc > 0)) {
5068+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5069+ }
5070+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5071+ if (!SWIG_IsOK(res1)) {
5072+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","MAPS", 1, self ));
5073+ }
5074+ arg1 = (_mrcImageHeader *)(argp1);
5075+ result = (mrcImageParaTypeInteger) ((arg1)->MAPS);
5076+ vresult = SWIG_From_int((int)(result));
5077+ return vresult;
5078+fail:
5079+ return Qnil;
5080+}
5081+
5082+
5083+SWIGINTERN VALUE
5084+_wrap__mrcImageHeader_AMin_set(int argc, VALUE *argv, VALUE self) {
5085+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5086+ mrcImageParaTypeReal arg2 ;
5087+ void *argp1 = 0 ;
5088+ int res1 = 0 ;
5089+ float val2 ;
5090+ int ecode2 = 0 ;
5091+
5092+ if ((argc < 1) || (argc > 1)) {
5093+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5094+ }
5095+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5096+ if (!SWIG_IsOK(res1)) {
5097+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","AMin", 1, self ));
5098+ }
5099+ arg1 = (_mrcImageHeader *)(argp1);
5100+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
5101+ if (!SWIG_IsOK(ecode2)) {
5102+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMin", 2, argv[0] ));
5103+ }
5104+ arg2 = (mrcImageParaTypeReal)(val2);
5105+ if (arg1) (arg1)->AMin = arg2;
5106+ return Qnil;
5107+fail:
5108+ return Qnil;
5109+}
5110+
5111+
5112+SWIGINTERN VALUE
5113+_wrap__mrcImageHeader_AMin_get(int argc, VALUE *argv, VALUE self) {
5114+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5115+ void *argp1 = 0 ;
5116+ int res1 = 0 ;
5117+ mrcImageParaTypeReal result;
5118+ VALUE vresult = Qnil;
5119+
5120+ if ((argc < 0) || (argc > 0)) {
5121+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5122+ }
5123+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5124+ if (!SWIG_IsOK(res1)) {
5125+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","AMin", 1, self ));
5126+ }
5127+ arg1 = (_mrcImageHeader *)(argp1);
5128+ result = (mrcImageParaTypeReal) ((arg1)->AMin);
5129+ vresult = SWIG_From_float((float)(result));
5130+ return vresult;
5131+fail:
5132+ return Qnil;
5133+}
5134+
5135+
5136+SWIGINTERN VALUE
5137+_wrap__mrcImageHeader_AMax_set(int argc, VALUE *argv, VALUE self) {
5138+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5139+ mrcImageParaTypeReal arg2 ;
5140+ void *argp1 = 0 ;
5141+ int res1 = 0 ;
5142+ float val2 ;
5143+ int ecode2 = 0 ;
5144+
5145+ if ((argc < 1) || (argc > 1)) {
5146+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5147+ }
5148+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5149+ if (!SWIG_IsOK(res1)) {
5150+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","AMax", 1, self ));
5151+ }
5152+ arg1 = (_mrcImageHeader *)(argp1);
5153+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
5154+ if (!SWIG_IsOK(ecode2)) {
5155+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMax", 2, argv[0] ));
5156+ }
5157+ arg2 = (mrcImageParaTypeReal)(val2);
5158+ if (arg1) (arg1)->AMax = arg2;
5159+ return Qnil;
5160+fail:
5161+ return Qnil;
5162+}
5163+
5164+
5165+SWIGINTERN VALUE
5166+_wrap__mrcImageHeader_AMax_get(int argc, VALUE *argv, VALUE self) {
5167+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5168+ void *argp1 = 0 ;
5169+ int res1 = 0 ;
5170+ mrcImageParaTypeReal result;
5171+ VALUE vresult = Qnil;
5172+
5173+ if ((argc < 0) || (argc > 0)) {
5174+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5175+ }
5176+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5177+ if (!SWIG_IsOK(res1)) {
5178+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","AMax", 1, self ));
5179+ }
5180+ arg1 = (_mrcImageHeader *)(argp1);
5181+ result = (mrcImageParaTypeReal) ((arg1)->AMax);
5182+ vresult = SWIG_From_float((float)(result));
5183+ return vresult;
5184+fail:
5185+ return Qnil;
5186+}
5187+
5188+
5189+SWIGINTERN VALUE
5190+_wrap__mrcImageHeader_AMean_set(int argc, VALUE *argv, VALUE self) {
5191+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5192+ mrcImageParaTypeReal arg2 ;
5193+ void *argp1 = 0 ;
5194+ int res1 = 0 ;
5195+ float val2 ;
5196+ int ecode2 = 0 ;
5197+
5198+ if ((argc < 1) || (argc > 1)) {
5199+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5200+ }
5201+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5202+ if (!SWIG_IsOK(res1)) {
5203+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","AMean", 1, self ));
5204+ }
5205+ arg1 = (_mrcImageHeader *)(argp1);
5206+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
5207+ if (!SWIG_IsOK(ecode2)) {
5208+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMean", 2, argv[0] ));
5209+ }
5210+ arg2 = (mrcImageParaTypeReal)(val2);
5211+ if (arg1) (arg1)->AMean = arg2;
5212+ return Qnil;
5213+fail:
5214+ return Qnil;
5215+}
5216+
5217+
5218+SWIGINTERN VALUE
5219+_wrap__mrcImageHeader_AMean_get(int argc, VALUE *argv, VALUE self) {
5220+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5221+ void *argp1 = 0 ;
5222+ int res1 = 0 ;
5223+ mrcImageParaTypeReal result;
5224+ VALUE vresult = Qnil;
5225+
5226+ if ((argc < 0) || (argc > 0)) {
5227+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5228+ }
5229+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5230+ if (!SWIG_IsOK(res1)) {
5231+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","AMean", 1, self ));
5232+ }
5233+ arg1 = (_mrcImageHeader *)(argp1);
5234+ result = (mrcImageParaTypeReal) ((arg1)->AMean);
5235+ vresult = SWIG_From_float((float)(result));
5236+ return vresult;
5237+fail:
5238+ return Qnil;
5239+}
5240+
5241+
5242+SWIGINTERN VALUE
5243+_wrap__mrcImageHeader_ISPG_set(int argc, VALUE *argv, VALUE self) {
5244+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5245+ mrcImageParaTypeInteger arg2 ;
5246+ void *argp1 = 0 ;
5247+ int res1 = 0 ;
5248+ int val2 ;
5249+ int ecode2 = 0 ;
5250+
5251+ if ((argc < 1) || (argc > 1)) {
5252+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5253+ }
5254+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5255+ if (!SWIG_IsOK(res1)) {
5256+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","ISPG", 1, self ));
5257+ }
5258+ arg1 = (_mrcImageHeader *)(argp1);
5259+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
5260+ if (!SWIG_IsOK(ecode2)) {
5261+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","ISPG", 2, argv[0] ));
5262+ }
5263+ arg2 = (mrcImageParaTypeInteger)(val2);
5264+ if (arg1) (arg1)->ISPG = arg2;
5265+ return Qnil;
5266+fail:
5267+ return Qnil;
5268+}
5269+
5270+
5271+SWIGINTERN VALUE
5272+_wrap__mrcImageHeader_ISPG_get(int argc, VALUE *argv, VALUE self) {
5273+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5274+ void *argp1 = 0 ;
5275+ int res1 = 0 ;
5276+ mrcImageParaTypeInteger result;
5277+ VALUE vresult = Qnil;
5278+
5279+ if ((argc < 0) || (argc > 0)) {
5280+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5281+ }
5282+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5283+ if (!SWIG_IsOK(res1)) {
5284+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","ISPG", 1, self ));
5285+ }
5286+ arg1 = (_mrcImageHeader *)(argp1);
5287+ result = (mrcImageParaTypeInteger) ((arg1)->ISPG);
5288+ vresult = SWIG_From_int((int)(result));
5289+ return vresult;
5290+fail:
5291+ return Qnil;
5292+}
5293+
5294+
5295+SWIGINTERN VALUE
5296+_wrap__mrcImageHeader_NSYMBT_set(int argc, VALUE *argv, VALUE self) {
5297+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5298+ mrcImageParaTypeInteger arg2 ;
5299+ void *argp1 = 0 ;
5300+ int res1 = 0 ;
5301+ int val2 ;
5302+ int ecode2 = 0 ;
5303+
5304+ if ((argc < 1) || (argc > 1)) {
5305+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5306+ }
5307+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5308+ if (!SWIG_IsOK(res1)) {
5309+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","NSYMBT", 1, self ));
5310+ }
5311+ arg1 = (_mrcImageHeader *)(argp1);
5312+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
5313+ if (!SWIG_IsOK(ecode2)) {
5314+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","NSYMBT", 2, argv[0] ));
5315+ }
5316+ arg2 = (mrcImageParaTypeInteger)(val2);
5317+ if (arg1) (arg1)->NSYMBT = arg2;
5318+ return Qnil;
5319+fail:
5320+ return Qnil;
5321+}
5322+
5323+
5324+SWIGINTERN VALUE
5325+_wrap__mrcImageHeader_NSYMBT_get(int argc, VALUE *argv, VALUE self) {
5326+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5327+ void *argp1 = 0 ;
5328+ int res1 = 0 ;
5329+ mrcImageParaTypeInteger result;
5330+ VALUE vresult = Qnil;
5331+
5332+ if ((argc < 0) || (argc > 0)) {
5333+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5334+ }
5335+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5336+ if (!SWIG_IsOK(res1)) {
5337+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","NSYMBT", 1, self ));
5338+ }
5339+ arg1 = (_mrcImageHeader *)(argp1);
5340+ result = (mrcImageParaTypeInteger) ((arg1)->NSYMBT);
5341+ vresult = SWIG_From_int((int)(result));
5342+ return vresult;
5343+fail:
5344+ return Qnil;
5345+}
5346+
5347+
5348+SWIGINTERN VALUE
5349+_wrap__mrcImageHeader_EXTRA_set(int argc, VALUE *argv, VALUE self) {
5350+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5351+ mrcImageParaTypeReal *arg2 ;
5352+ void *argp1 = 0 ;
5353+ int res1 = 0 ;
5354+ void *argp2 = 0 ;
5355+ int res2 = 0 ;
5356+
5357+ if ((argc < 1) || (argc > 1)) {
5358+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5359+ }
5360+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5361+ if (!SWIG_IsOK(res1)) {
5362+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","EXTRA", 1, self ));
5363+ }
5364+ arg1 = (_mrcImageHeader *)(argp1);
5365+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
5366+ if (!SWIG_IsOK(res2)) {
5367+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [(29)]","EXTRA", 2, argv[0] ));
5368+ }
5369+ arg2 = (mrcImageParaTypeReal *)(argp2);
5370+ {
5371+ if (arg2) {
5372+ size_t ii = 0;
5373+ for (; ii < (size_t)(29); ++ii) arg1->EXTRA[ii] = arg2[ii];
5374+ } else {
5375+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""EXTRA""' of type '""mrcImageParaTypeReal [(29)]""'");
5376+ }
5377+ }
5378+ return Qnil;
5379+fail:
5380+ return Qnil;
5381+}
5382+
5383+
5384+SWIGINTERN VALUE
5385+_wrap__mrcImageHeader_EXTRA_get(int argc, VALUE *argv, VALUE self) {
5386+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5387+ void *argp1 = 0 ;
5388+ int res1 = 0 ;
5389+ mrcImageParaTypeReal *result = 0 ;
5390+ VALUE vresult = Qnil;
5391+
5392+ if ((argc < 0) || (argc > 0)) {
5393+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5394+ }
5395+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5396+ if (!SWIG_IsOK(res1)) {
5397+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","EXTRA", 1, self ));
5398+ }
5399+ arg1 = (_mrcImageHeader *)(argp1);
5400+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->EXTRA);
5401+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
5402+ return vresult;
5403+fail:
5404+ return Qnil;
5405+}
5406+
5407+
5408+SWIGINTERN VALUE
5409+_wrap__mrcImageHeader_OriginX_set(int argc, VALUE *argv, VALUE self) {
5410+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5411+ mrcImageParaTypeReal arg2 ;
5412+ void *argp1 = 0 ;
5413+ int res1 = 0 ;
5414+ float val2 ;
5415+ int ecode2 = 0 ;
5416+
5417+ if ((argc < 1) || (argc > 1)) {
5418+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5419+ }
5420+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5421+ if (!SWIG_IsOK(res1)) {
5422+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","OriginX", 1, self ));
5423+ }
5424+ arg1 = (_mrcImageHeader *)(argp1);
5425+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
5426+ if (!SWIG_IsOK(ecode2)) {
5427+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","OriginX", 2, argv[0] ));
5428+ }
5429+ arg2 = (mrcImageParaTypeReal)(val2);
5430+ if (arg1) (arg1)->OriginX = arg2;
5431+ return Qnil;
5432+fail:
5433+ return Qnil;
5434+}
5435+
5436+
5437+SWIGINTERN VALUE
5438+_wrap__mrcImageHeader_OriginX_get(int argc, VALUE *argv, VALUE self) {
5439+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5440+ void *argp1 = 0 ;
5441+ int res1 = 0 ;
5442+ mrcImageParaTypeReal result;
5443+ VALUE vresult = Qnil;
5444+
5445+ if ((argc < 0) || (argc > 0)) {
5446+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5447+ }
5448+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5449+ if (!SWIG_IsOK(res1)) {
5450+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","OriginX", 1, self ));
5451+ }
5452+ arg1 = (_mrcImageHeader *)(argp1);
5453+ result = (mrcImageParaTypeReal) ((arg1)->OriginX);
5454+ vresult = SWIG_From_float((float)(result));
5455+ return vresult;
5456+fail:
5457+ return Qnil;
5458+}
5459+
5460+
5461+SWIGINTERN VALUE
5462+_wrap__mrcImageHeader_OriginY_set(int argc, VALUE *argv, VALUE self) {
5463+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5464+ mrcImageParaTypeReal arg2 ;
5465+ void *argp1 = 0 ;
5466+ int res1 = 0 ;
5467+ float val2 ;
5468+ int ecode2 = 0 ;
5469+
5470+ if ((argc < 1) || (argc > 1)) {
5471+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5472+ }
5473+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5474+ if (!SWIG_IsOK(res1)) {
5475+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","OriginY", 1, self ));
5476+ }
5477+ arg1 = (_mrcImageHeader *)(argp1);
5478+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
5479+ if (!SWIG_IsOK(ecode2)) {
5480+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","OriginY", 2, argv[0] ));
5481+ }
5482+ arg2 = (mrcImageParaTypeReal)(val2);
5483+ if (arg1) (arg1)->OriginY = arg2;
5484+ return Qnil;
5485+fail:
5486+ return Qnil;
5487+}
5488+
5489+
5490+SWIGINTERN VALUE
5491+_wrap__mrcImageHeader_OriginY_get(int argc, VALUE *argv, VALUE self) {
5492+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5493+ void *argp1 = 0 ;
5494+ int res1 = 0 ;
5495+ mrcImageParaTypeReal result;
5496+ VALUE vresult = Qnil;
5497+
5498+ if ((argc < 0) || (argc > 0)) {
5499+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5500+ }
5501+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5502+ if (!SWIG_IsOK(res1)) {
5503+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","OriginY", 1, self ));
5504+ }
5505+ arg1 = (_mrcImageHeader *)(argp1);
5506+ result = (mrcImageParaTypeReal) ((arg1)->OriginY);
5507+ vresult = SWIG_From_float((float)(result));
5508+ return vresult;
5509+fail:
5510+ return Qnil;
5511+}
5512+
5513+
5514+SWIGINTERN VALUE
5515+_wrap__mrcImageHeader_LabelN_set(int argc, VALUE *argv, VALUE self) {
5516+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5517+ mrcImageParaTypeInteger arg2 ;
5518+ void *argp1 = 0 ;
5519+ int res1 = 0 ;
5520+ int val2 ;
5521+ int ecode2 = 0 ;
5522+
5523+ if ((argc < 1) || (argc > 1)) {
5524+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5525+ }
5526+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5527+ if (!SWIG_IsOK(res1)) {
5528+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","LabelN", 1, self ));
5529+ }
5530+ arg1 = (_mrcImageHeader *)(argp1);
5531+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
5532+ if (!SWIG_IsOK(ecode2)) {
5533+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","LabelN", 2, argv[0] ));
5534+ }
5535+ arg2 = (mrcImageParaTypeInteger)(val2);
5536+ if (arg1) (arg1)->LabelN = arg2;
5537+ return Qnil;
5538+fail:
5539+ return Qnil;
5540+}
5541+
5542+
5543+SWIGINTERN VALUE
5544+_wrap__mrcImageHeader_LabelN_get(int argc, VALUE *argv, VALUE self) {
5545+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5546+ void *argp1 = 0 ;
5547+ int res1 = 0 ;
5548+ mrcImageParaTypeInteger result;
5549+ VALUE vresult = Qnil;
5550+
5551+ if ((argc < 0) || (argc > 0)) {
5552+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5553+ }
5554+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5555+ if (!SWIG_IsOK(res1)) {
5556+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","LabelN", 1, self ));
5557+ }
5558+ arg1 = (_mrcImageHeader *)(argp1);
5559+ result = (mrcImageParaTypeInteger) ((arg1)->LabelN);
5560+ vresult = SWIG_From_int((int)(result));
5561+ return vresult;
5562+fail:
5563+ return Qnil;
5564+}
5565+
5566+
5567+SWIGINTERN VALUE
5568+_wrap__mrcImageHeader_Label_set(int argc, VALUE *argv, VALUE self) {
5569+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5570+ char (*arg2)[(80)] ;
5571+ void *argp1 = 0 ;
5572+ int res1 = 0 ;
5573+ void *argp2 = 0 ;
5574+ int res2 = 0 ;
5575+
5576+ if ((argc < 1) || (argc > 1)) {
5577+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5578+ }
5579+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5580+ if (!SWIG_IsOK(res1)) {
5581+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Label", 1, self ));
5582+ }
5583+ arg1 = (_mrcImageHeader *)(argp1);
5584+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_a__80___char, 0 | 0 );
5585+ if (!SWIG_IsOK(res2)) {
5586+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [(10)][(80)]","Label", 2, argv[0] ));
5587+ }
5588+ arg2 = (char (*)[(80)])(argp2);
5589+ {
5590+ if (arg2) {
5591+ size_t ii = 0;
5592+ for (; ii < (size_t)(10); ++ii) {
5593+ if (arg2[ii]) {
5594+ size_t jj = 0;
5595+ for (; jj < (size_t)(80); ++jj) arg1->Label[ii][jj] = arg2[ii][jj];
5596+ } else {
5597+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Label""' of type '""char [(10)][(80)]""'");
5598+ }
5599+ }
5600+ } else {
5601+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Label""' of type '""char [(10)][(80)]""'");
5602+ }
5603+ }
5604+ return Qnil;
5605+fail:
5606+ return Qnil;
5607+}
5608+
5609+
5610+SWIGINTERN VALUE
5611+_wrap__mrcImageHeader_Label_get(int argc, VALUE *argv, VALUE self) {
5612+ _mrcImageHeader *arg1 = (_mrcImageHeader *) 0 ;
5613+ void *argp1 = 0 ;
5614+ int res1 = 0 ;
5615+ char (*result)[(80)] = 0 ;
5616+ VALUE vresult = Qnil;
5617+
5618+ if ((argc < 0) || (argc > 0)) {
5619+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5620+ }
5621+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
5622+ if (!SWIG_IsOK(res1)) {
5623+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeader *","Label", 1, self ));
5624+ }
5625+ arg1 = (_mrcImageHeader *)(argp1);
5626+ result = (char (*)[(80)])(char (*)[(80)]) ((arg1)->Label);
5627+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a__80___char, 0 | 0 );
5628+ return vresult;
5629+fail:
5630+ return Qnil;
5631+}
5632+
5633+
5634+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
5635+SWIGINTERN VALUE
5636+_wrap__mrcImageHeader_allocate(VALUE self) {
5637+#else
5638+ SWIGINTERN VALUE
5639+ _wrap__mrcImageHeader_allocate(int argc, VALUE *argv, VALUE self) {
5640+#endif
5641+
5642+
5643+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p__mrcImageHeader);
5644+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
5645+ rb_obj_call_init(vresult, argc, argv);
5646+#endif
5647+ return vresult;
5648+ }
5649+
5650+
5651+SWIGINTERN VALUE
5652+_wrap_new__mrcImageHeader(int argc, VALUE *argv, VALUE self) {
5653+ _mrcImageHeader *result = 0 ;
5654+
5655+ if ((argc < 0) || (argc > 0)) {
5656+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5657+ }
5658+ result = (_mrcImageHeader *)calloc(1, sizeof(_mrcImageHeader));
5659+ DATA_PTR(self) = result;
5660+ return self;
5661+fail:
5662+ return Qnil;
5663+}
5664+
5665+
5666+SWIGINTERN void
5667+free__mrcImageHeader(_mrcImageHeader *arg1) {
5668+ free((char *) arg1);
5669+}
5670+
5671+swig_class SwigClass_mrcImageHeaderCCP4;
5672+
5673+SWIGINTERN VALUE
5674+_wrap__mrcImageHeaderCCP4_N_set(int argc, VALUE *argv, VALUE self) {
5675+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5676+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
5677+ void *argp1 = 0 ;
5678+ int res1 = 0 ;
5679+ void *argp2 = 0 ;
5680+ int res2 = 0 ;
5681+
5682+ if ((argc < 1) || (argc > 1)) {
5683+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5684+ }
5685+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5686+ if (!SWIG_IsOK(res1)) {
5687+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","N", 1, self ));
5688+ }
5689+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5690+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
5691+ if (!SWIG_IsOK(res2)) {
5692+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","N", 2, argv[0] ));
5693+ }
5694+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
5695+ if (arg1) (arg1)->N = *arg2;
5696+ return Qnil;
5697+fail:
5698+ return Qnil;
5699+}
5700+
5701+
5702+SWIGINTERN VALUE
5703+_wrap__mrcImageHeaderCCP4_N_get(int argc, VALUE *argv, VALUE self) {
5704+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5705+ void *argp1 = 0 ;
5706+ int res1 = 0 ;
5707+ mrcImageParaTypeIntegerCoord *result = 0 ;
5708+ VALUE vresult = Qnil;
5709+
5710+ if ((argc < 0) || (argc > 0)) {
5711+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5712+ }
5713+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5714+ if (!SWIG_IsOK(res1)) {
5715+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","N", 1, self ));
5716+ }
5717+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5718+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->N);
5719+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
5720+ return vresult;
5721+fail:
5722+ return Qnil;
5723+}
5724+
5725+
5726+SWIGINTERN VALUE
5727+_wrap__mrcImageHeaderCCP4_Mode_set(int argc, VALUE *argv, VALUE self) {
5728+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5729+ mrcImageMode arg2 ;
5730+ void *argp1 = 0 ;
5731+ int res1 = 0 ;
5732+ int val2 ;
5733+ int ecode2 = 0 ;
5734+
5735+ if ((argc < 1) || (argc > 1)) {
5736+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5737+ }
5738+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5739+ if (!SWIG_IsOK(res1)) {
5740+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Mode", 1, self ));
5741+ }
5742+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5743+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
5744+ if (!SWIG_IsOK(ecode2)) {
5745+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageMode","Mode", 2, argv[0] ));
5746+ }
5747+ arg2 = (mrcImageMode)(val2);
5748+ if (arg1) (arg1)->Mode = arg2;
5749+ return Qnil;
5750+fail:
5751+ return Qnil;
5752+}
5753+
5754+
5755+SWIGINTERN VALUE
5756+_wrap__mrcImageHeaderCCP4_Mode_get(int argc, VALUE *argv, VALUE self) {
5757+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5758+ void *argp1 = 0 ;
5759+ int res1 = 0 ;
5760+ mrcImageMode result;
5761+ VALUE vresult = Qnil;
5762+
5763+ if ((argc < 0) || (argc > 0)) {
5764+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5765+ }
5766+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5767+ if (!SWIG_IsOK(res1)) {
5768+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Mode", 1, self ));
5769+ }
5770+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5771+ result = (mrcImageMode) ((arg1)->Mode);
5772+ vresult = SWIG_From_int((int)(result));
5773+ return vresult;
5774+fail:
5775+ return Qnil;
5776+}
5777+
5778+
5779+SWIGINTERN VALUE
5780+_wrap__mrcImageHeaderCCP4_StartN_set(int argc, VALUE *argv, VALUE self) {
5781+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5782+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
5783+ void *argp1 = 0 ;
5784+ int res1 = 0 ;
5785+ void *argp2 = 0 ;
5786+ int res2 = 0 ;
5787+
5788+ if ((argc < 1) || (argc > 1)) {
5789+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5790+ }
5791+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5792+ if (!SWIG_IsOK(res1)) {
5793+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","StartN", 1, self ));
5794+ }
5795+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5796+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
5797+ if (!SWIG_IsOK(res2)) {
5798+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","StartN", 2, argv[0] ));
5799+ }
5800+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
5801+ if (arg1) (arg1)->StartN = *arg2;
5802+ return Qnil;
5803+fail:
5804+ return Qnil;
5805+}
5806+
5807+
5808+SWIGINTERN VALUE
5809+_wrap__mrcImageHeaderCCP4_StartN_get(int argc, VALUE *argv, VALUE self) {
5810+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5811+ void *argp1 = 0 ;
5812+ int res1 = 0 ;
5813+ mrcImageParaTypeIntegerCoord *result = 0 ;
5814+ VALUE vresult = Qnil;
5815+
5816+ if ((argc < 0) || (argc > 0)) {
5817+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5818+ }
5819+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5820+ if (!SWIG_IsOK(res1)) {
5821+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","StartN", 1, self ));
5822+ }
5823+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5824+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->StartN);
5825+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
5826+ return vresult;
5827+fail:
5828+ return Qnil;
5829+}
5830+
5831+
5832+SWIGINTERN VALUE
5833+_wrap__mrcImageHeaderCCP4_NI_set(int argc, VALUE *argv, VALUE self) {
5834+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5835+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
5836+ void *argp1 = 0 ;
5837+ int res1 = 0 ;
5838+ void *argp2 = 0 ;
5839+ int res2 = 0 ;
5840+
5841+ if ((argc < 1) || (argc > 1)) {
5842+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5843+ }
5844+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5845+ if (!SWIG_IsOK(res1)) {
5846+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","NI", 1, self ));
5847+ }
5848+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5849+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
5850+ if (!SWIG_IsOK(res2)) {
5851+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","NI", 2, argv[0] ));
5852+ }
5853+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
5854+ if (arg1) (arg1)->NI = *arg2;
5855+ return Qnil;
5856+fail:
5857+ return Qnil;
5858+}
5859+
5860+
5861+SWIGINTERN VALUE
5862+_wrap__mrcImageHeaderCCP4_NI_get(int argc, VALUE *argv, VALUE self) {
5863+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5864+ void *argp1 = 0 ;
5865+ int res1 = 0 ;
5866+ mrcImageParaTypeIntegerCoord *result = 0 ;
5867+ VALUE vresult = Qnil;
5868+
5869+ if ((argc < 0) || (argc > 0)) {
5870+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5871+ }
5872+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5873+ if (!SWIG_IsOK(res1)) {
5874+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","NI", 1, self ));
5875+ }
5876+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5877+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->NI);
5878+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
5879+ return vresult;
5880+fail:
5881+ return Qnil;
5882+}
5883+
5884+
5885+SWIGINTERN VALUE
5886+_wrap__mrcImageHeaderCCP4_Length_set(int argc, VALUE *argv, VALUE self) {
5887+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5888+ mrcImageParaTypeRealCoord *arg2 = (mrcImageParaTypeRealCoord *) 0 ;
5889+ void *argp1 = 0 ;
5890+ int res1 = 0 ;
5891+ void *argp2 = 0 ;
5892+ int res2 = 0 ;
5893+
5894+ if ((argc < 1) || (argc > 1)) {
5895+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5896+ }
5897+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5898+ if (!SWIG_IsOK(res1)) {
5899+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Length", 1, self ));
5900+ }
5901+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5902+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
5903+ if (!SWIG_IsOK(res2)) {
5904+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","Length", 2, argv[0] ));
5905+ }
5906+ arg2 = (mrcImageParaTypeRealCoord *)(argp2);
5907+ if (arg1) (arg1)->Length = *arg2;
5908+ return Qnil;
5909+fail:
5910+ return Qnil;
5911+}
5912+
5913+
5914+SWIGINTERN VALUE
5915+_wrap__mrcImageHeaderCCP4_Length_get(int argc, VALUE *argv, VALUE self) {
5916+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5917+ void *argp1 = 0 ;
5918+ int res1 = 0 ;
5919+ mrcImageParaTypeRealCoord *result = 0 ;
5920+ VALUE vresult = Qnil;
5921+
5922+ if ((argc < 0) || (argc > 0)) {
5923+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5924+ }
5925+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5926+ if (!SWIG_IsOK(res1)) {
5927+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Length", 1, self ));
5928+ }
5929+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5930+ result = (mrcImageParaTypeRealCoord *)& ((arg1)->Length);
5931+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
5932+ return vresult;
5933+fail:
5934+ return Qnil;
5935+}
5936+
5937+
5938+SWIGINTERN VALUE
5939+_wrap__mrcImageHeaderCCP4_Alpha_set(int argc, VALUE *argv, VALUE self) {
5940+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5941+ mrcImageParaTypeReal arg2 ;
5942+ void *argp1 = 0 ;
5943+ int res1 = 0 ;
5944+ float val2 ;
5945+ int ecode2 = 0 ;
5946+
5947+ if ((argc < 1) || (argc > 1)) {
5948+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
5949+ }
5950+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5951+ if (!SWIG_IsOK(res1)) {
5952+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Alpha", 1, self ));
5953+ }
5954+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5955+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
5956+ if (!SWIG_IsOK(ecode2)) {
5957+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Alpha", 2, argv[0] ));
5958+ }
5959+ arg2 = (mrcImageParaTypeReal)(val2);
5960+ if (arg1) (arg1)->Alpha = arg2;
5961+ return Qnil;
5962+fail:
5963+ return Qnil;
5964+}
5965+
5966+
5967+SWIGINTERN VALUE
5968+_wrap__mrcImageHeaderCCP4_Alpha_get(int argc, VALUE *argv, VALUE self) {
5969+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5970+ void *argp1 = 0 ;
5971+ int res1 = 0 ;
5972+ mrcImageParaTypeReal result;
5973+ VALUE vresult = Qnil;
5974+
5975+ if ((argc < 0) || (argc > 0)) {
5976+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
5977+ }
5978+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
5979+ if (!SWIG_IsOK(res1)) {
5980+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Alpha", 1, self ));
5981+ }
5982+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
5983+ result = (mrcImageParaTypeReal) ((arg1)->Alpha);
5984+ vresult = SWIG_From_float((float)(result));
5985+ return vresult;
5986+fail:
5987+ return Qnil;
5988+}
5989+
5990+
5991+SWIGINTERN VALUE
5992+_wrap__mrcImageHeaderCCP4_Beta_set(int argc, VALUE *argv, VALUE self) {
5993+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
5994+ mrcImageParaTypeReal arg2 ;
5995+ void *argp1 = 0 ;
5996+ int res1 = 0 ;
5997+ float val2 ;
5998+ int ecode2 = 0 ;
5999+
6000+ if ((argc < 1) || (argc > 1)) {
6001+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6002+ }
6003+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6004+ if (!SWIG_IsOK(res1)) {
6005+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Beta", 1, self ));
6006+ }
6007+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6008+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
6009+ if (!SWIG_IsOK(ecode2)) {
6010+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Beta", 2, argv[0] ));
6011+ }
6012+ arg2 = (mrcImageParaTypeReal)(val2);
6013+ if (arg1) (arg1)->Beta = arg2;
6014+ return Qnil;
6015+fail:
6016+ return Qnil;
6017+}
6018+
6019+
6020+SWIGINTERN VALUE
6021+_wrap__mrcImageHeaderCCP4_Beta_get(int argc, VALUE *argv, VALUE self) {
6022+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6023+ void *argp1 = 0 ;
6024+ int res1 = 0 ;
6025+ mrcImageParaTypeReal result;
6026+ VALUE vresult = Qnil;
6027+
6028+ if ((argc < 0) || (argc > 0)) {
6029+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6030+ }
6031+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6032+ if (!SWIG_IsOK(res1)) {
6033+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Beta", 1, self ));
6034+ }
6035+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6036+ result = (mrcImageParaTypeReal) ((arg1)->Beta);
6037+ vresult = SWIG_From_float((float)(result));
6038+ return vresult;
6039+fail:
6040+ return Qnil;
6041+}
6042+
6043+
6044+SWIGINTERN VALUE
6045+_wrap__mrcImageHeaderCCP4_Gamma_set(int argc, VALUE *argv, VALUE self) {
6046+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6047+ mrcImageParaTypeReal arg2 ;
6048+ void *argp1 = 0 ;
6049+ int res1 = 0 ;
6050+ float val2 ;
6051+ int ecode2 = 0 ;
6052+
6053+ if ((argc < 1) || (argc > 1)) {
6054+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6055+ }
6056+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6057+ if (!SWIG_IsOK(res1)) {
6058+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Gamma", 1, self ));
6059+ }
6060+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6061+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
6062+ if (!SWIG_IsOK(ecode2)) {
6063+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Gamma", 2, argv[0] ));
6064+ }
6065+ arg2 = (mrcImageParaTypeReal)(val2);
6066+ if (arg1) (arg1)->Gamma = arg2;
6067+ return Qnil;
6068+fail:
6069+ return Qnil;
6070+}
6071+
6072+
6073+SWIGINTERN VALUE
6074+_wrap__mrcImageHeaderCCP4_Gamma_get(int argc, VALUE *argv, VALUE self) {
6075+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6076+ void *argp1 = 0 ;
6077+ int res1 = 0 ;
6078+ mrcImageParaTypeReal result;
6079+ VALUE vresult = Qnil;
6080+
6081+ if ((argc < 0) || (argc > 0)) {
6082+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6083+ }
6084+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6085+ if (!SWIG_IsOK(res1)) {
6086+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Gamma", 1, self ));
6087+ }
6088+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6089+ result = (mrcImageParaTypeReal) ((arg1)->Gamma);
6090+ vresult = SWIG_From_float((float)(result));
6091+ return vresult;
6092+fail:
6093+ return Qnil;
6094+}
6095+
6096+
6097+SWIGINTERN VALUE
6098+_wrap__mrcImageHeaderCCP4_MAPC_set(int argc, VALUE *argv, VALUE self) {
6099+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6100+ mrcImageParaTypeInteger arg2 ;
6101+ void *argp1 = 0 ;
6102+ int res1 = 0 ;
6103+ int val2 ;
6104+ int ecode2 = 0 ;
6105+
6106+ if ((argc < 1) || (argc > 1)) {
6107+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6108+ }
6109+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6110+ if (!SWIG_IsOK(res1)) {
6111+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MAPC", 1, self ));
6112+ }
6113+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6114+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6115+ if (!SWIG_IsOK(ecode2)) {
6116+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPC", 2, argv[0] ));
6117+ }
6118+ arg2 = (mrcImageParaTypeInteger)(val2);
6119+ if (arg1) (arg1)->MAPC = arg2;
6120+ return Qnil;
6121+fail:
6122+ return Qnil;
6123+}
6124+
6125+
6126+SWIGINTERN VALUE
6127+_wrap__mrcImageHeaderCCP4_MAPC_get(int argc, VALUE *argv, VALUE self) {
6128+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6129+ void *argp1 = 0 ;
6130+ int res1 = 0 ;
6131+ mrcImageParaTypeInteger result;
6132+ VALUE vresult = Qnil;
6133+
6134+ if ((argc < 0) || (argc > 0)) {
6135+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6136+ }
6137+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6138+ if (!SWIG_IsOK(res1)) {
6139+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MAPC", 1, self ));
6140+ }
6141+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6142+ result = (mrcImageParaTypeInteger) ((arg1)->MAPC);
6143+ vresult = SWIG_From_int((int)(result));
6144+ return vresult;
6145+fail:
6146+ return Qnil;
6147+}
6148+
6149+
6150+SWIGINTERN VALUE
6151+_wrap__mrcImageHeaderCCP4_MAPR_set(int argc, VALUE *argv, VALUE self) {
6152+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6153+ mrcImageParaTypeInteger arg2 ;
6154+ void *argp1 = 0 ;
6155+ int res1 = 0 ;
6156+ int val2 ;
6157+ int ecode2 = 0 ;
6158+
6159+ if ((argc < 1) || (argc > 1)) {
6160+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6161+ }
6162+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6163+ if (!SWIG_IsOK(res1)) {
6164+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MAPR", 1, self ));
6165+ }
6166+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6167+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6168+ if (!SWIG_IsOK(ecode2)) {
6169+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPR", 2, argv[0] ));
6170+ }
6171+ arg2 = (mrcImageParaTypeInteger)(val2);
6172+ if (arg1) (arg1)->MAPR = arg2;
6173+ return Qnil;
6174+fail:
6175+ return Qnil;
6176+}
6177+
6178+
6179+SWIGINTERN VALUE
6180+_wrap__mrcImageHeaderCCP4_MAPR_get(int argc, VALUE *argv, VALUE self) {
6181+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6182+ void *argp1 = 0 ;
6183+ int res1 = 0 ;
6184+ mrcImageParaTypeInteger result;
6185+ VALUE vresult = Qnil;
6186+
6187+ if ((argc < 0) || (argc > 0)) {
6188+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6189+ }
6190+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6191+ if (!SWIG_IsOK(res1)) {
6192+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MAPR", 1, self ));
6193+ }
6194+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6195+ result = (mrcImageParaTypeInteger) ((arg1)->MAPR);
6196+ vresult = SWIG_From_int((int)(result));
6197+ return vresult;
6198+fail:
6199+ return Qnil;
6200+}
6201+
6202+
6203+SWIGINTERN VALUE
6204+_wrap__mrcImageHeaderCCP4_MAPS_set(int argc, VALUE *argv, VALUE self) {
6205+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6206+ mrcImageParaTypeInteger arg2 ;
6207+ void *argp1 = 0 ;
6208+ int res1 = 0 ;
6209+ int val2 ;
6210+ int ecode2 = 0 ;
6211+
6212+ if ((argc < 1) || (argc > 1)) {
6213+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6214+ }
6215+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6216+ if (!SWIG_IsOK(res1)) {
6217+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MAPS", 1, self ));
6218+ }
6219+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6220+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6221+ if (!SWIG_IsOK(ecode2)) {
6222+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPS", 2, argv[0] ));
6223+ }
6224+ arg2 = (mrcImageParaTypeInteger)(val2);
6225+ if (arg1) (arg1)->MAPS = arg2;
6226+ return Qnil;
6227+fail:
6228+ return Qnil;
6229+}
6230+
6231+
6232+SWIGINTERN VALUE
6233+_wrap__mrcImageHeaderCCP4_MAPS_get(int argc, VALUE *argv, VALUE self) {
6234+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6235+ void *argp1 = 0 ;
6236+ int res1 = 0 ;
6237+ mrcImageParaTypeInteger result;
6238+ VALUE vresult = Qnil;
6239+
6240+ if ((argc < 0) || (argc > 0)) {
6241+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6242+ }
6243+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6244+ if (!SWIG_IsOK(res1)) {
6245+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MAPS", 1, self ));
6246+ }
6247+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6248+ result = (mrcImageParaTypeInteger) ((arg1)->MAPS);
6249+ vresult = SWIG_From_int((int)(result));
6250+ return vresult;
6251+fail:
6252+ return Qnil;
6253+}
6254+
6255+
6256+SWIGINTERN VALUE
6257+_wrap__mrcImageHeaderCCP4_AMin_set(int argc, VALUE *argv, VALUE self) {
6258+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6259+ mrcImageParaTypeReal arg2 ;
6260+ void *argp1 = 0 ;
6261+ int res1 = 0 ;
6262+ float val2 ;
6263+ int ecode2 = 0 ;
6264+
6265+ if ((argc < 1) || (argc > 1)) {
6266+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6267+ }
6268+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6269+ if (!SWIG_IsOK(res1)) {
6270+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","AMin", 1, self ));
6271+ }
6272+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6273+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
6274+ if (!SWIG_IsOK(ecode2)) {
6275+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMin", 2, argv[0] ));
6276+ }
6277+ arg2 = (mrcImageParaTypeReal)(val2);
6278+ if (arg1) (arg1)->AMin = arg2;
6279+ return Qnil;
6280+fail:
6281+ return Qnil;
6282+}
6283+
6284+
6285+SWIGINTERN VALUE
6286+_wrap__mrcImageHeaderCCP4_AMin_get(int argc, VALUE *argv, VALUE self) {
6287+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6288+ void *argp1 = 0 ;
6289+ int res1 = 0 ;
6290+ mrcImageParaTypeReal result;
6291+ VALUE vresult = Qnil;
6292+
6293+ if ((argc < 0) || (argc > 0)) {
6294+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6295+ }
6296+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6297+ if (!SWIG_IsOK(res1)) {
6298+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","AMin", 1, self ));
6299+ }
6300+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6301+ result = (mrcImageParaTypeReal) ((arg1)->AMin);
6302+ vresult = SWIG_From_float((float)(result));
6303+ return vresult;
6304+fail:
6305+ return Qnil;
6306+}
6307+
6308+
6309+SWIGINTERN VALUE
6310+_wrap__mrcImageHeaderCCP4_AMax_set(int argc, VALUE *argv, VALUE self) {
6311+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6312+ mrcImageParaTypeReal arg2 ;
6313+ void *argp1 = 0 ;
6314+ int res1 = 0 ;
6315+ float val2 ;
6316+ int ecode2 = 0 ;
6317+
6318+ if ((argc < 1) || (argc > 1)) {
6319+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6320+ }
6321+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6322+ if (!SWIG_IsOK(res1)) {
6323+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","AMax", 1, self ));
6324+ }
6325+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6326+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
6327+ if (!SWIG_IsOK(ecode2)) {
6328+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMax", 2, argv[0] ));
6329+ }
6330+ arg2 = (mrcImageParaTypeReal)(val2);
6331+ if (arg1) (arg1)->AMax = arg2;
6332+ return Qnil;
6333+fail:
6334+ return Qnil;
6335+}
6336+
6337+
6338+SWIGINTERN VALUE
6339+_wrap__mrcImageHeaderCCP4_AMax_get(int argc, VALUE *argv, VALUE self) {
6340+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6341+ void *argp1 = 0 ;
6342+ int res1 = 0 ;
6343+ mrcImageParaTypeReal result;
6344+ VALUE vresult = Qnil;
6345+
6346+ if ((argc < 0) || (argc > 0)) {
6347+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6348+ }
6349+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6350+ if (!SWIG_IsOK(res1)) {
6351+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","AMax", 1, self ));
6352+ }
6353+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6354+ result = (mrcImageParaTypeReal) ((arg1)->AMax);
6355+ vresult = SWIG_From_float((float)(result));
6356+ return vresult;
6357+fail:
6358+ return Qnil;
6359+}
6360+
6361+
6362+SWIGINTERN VALUE
6363+_wrap__mrcImageHeaderCCP4_AMean_set(int argc, VALUE *argv, VALUE self) {
6364+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6365+ mrcImageParaTypeReal arg2 ;
6366+ void *argp1 = 0 ;
6367+ int res1 = 0 ;
6368+ float val2 ;
6369+ int ecode2 = 0 ;
6370+
6371+ if ((argc < 1) || (argc > 1)) {
6372+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6373+ }
6374+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6375+ if (!SWIG_IsOK(res1)) {
6376+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","AMean", 1, self ));
6377+ }
6378+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6379+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
6380+ if (!SWIG_IsOK(ecode2)) {
6381+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMean", 2, argv[0] ));
6382+ }
6383+ arg2 = (mrcImageParaTypeReal)(val2);
6384+ if (arg1) (arg1)->AMean = arg2;
6385+ return Qnil;
6386+fail:
6387+ return Qnil;
6388+}
6389+
6390+
6391+SWIGINTERN VALUE
6392+_wrap__mrcImageHeaderCCP4_AMean_get(int argc, VALUE *argv, VALUE self) {
6393+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6394+ void *argp1 = 0 ;
6395+ int res1 = 0 ;
6396+ mrcImageParaTypeReal result;
6397+ VALUE vresult = Qnil;
6398+
6399+ if ((argc < 0) || (argc > 0)) {
6400+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6401+ }
6402+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6403+ if (!SWIG_IsOK(res1)) {
6404+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","AMean", 1, self ));
6405+ }
6406+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6407+ result = (mrcImageParaTypeReal) ((arg1)->AMean);
6408+ vresult = SWIG_From_float((float)(result));
6409+ return vresult;
6410+fail:
6411+ return Qnil;
6412+}
6413+
6414+
6415+SWIGINTERN VALUE
6416+_wrap__mrcImageHeaderCCP4_ISPG_set(int argc, VALUE *argv, VALUE self) {
6417+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6418+ mrcImageParaTypeInteger arg2 ;
6419+ void *argp1 = 0 ;
6420+ int res1 = 0 ;
6421+ int val2 ;
6422+ int ecode2 = 0 ;
6423+
6424+ if ((argc < 1) || (argc > 1)) {
6425+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6426+ }
6427+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6428+ if (!SWIG_IsOK(res1)) {
6429+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","ISPG", 1, self ));
6430+ }
6431+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6432+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6433+ if (!SWIG_IsOK(ecode2)) {
6434+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","ISPG", 2, argv[0] ));
6435+ }
6436+ arg2 = (mrcImageParaTypeInteger)(val2);
6437+ if (arg1) (arg1)->ISPG = arg2;
6438+ return Qnil;
6439+fail:
6440+ return Qnil;
6441+}
6442+
6443+
6444+SWIGINTERN VALUE
6445+_wrap__mrcImageHeaderCCP4_ISPG_get(int argc, VALUE *argv, VALUE self) {
6446+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6447+ void *argp1 = 0 ;
6448+ int res1 = 0 ;
6449+ mrcImageParaTypeInteger result;
6450+ VALUE vresult = Qnil;
6451+
6452+ if ((argc < 0) || (argc > 0)) {
6453+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6454+ }
6455+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6456+ if (!SWIG_IsOK(res1)) {
6457+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","ISPG", 1, self ));
6458+ }
6459+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6460+ result = (mrcImageParaTypeInteger) ((arg1)->ISPG);
6461+ vresult = SWIG_From_int((int)(result));
6462+ return vresult;
6463+fail:
6464+ return Qnil;
6465+}
6466+
6467+
6468+SWIGINTERN VALUE
6469+_wrap__mrcImageHeaderCCP4_NSYMBT_set(int argc, VALUE *argv, VALUE self) {
6470+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6471+ mrcImageParaTypeInteger arg2 ;
6472+ void *argp1 = 0 ;
6473+ int res1 = 0 ;
6474+ int val2 ;
6475+ int ecode2 = 0 ;
6476+
6477+ if ((argc < 1) || (argc > 1)) {
6478+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6479+ }
6480+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6481+ if (!SWIG_IsOK(res1)) {
6482+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","NSYMBT", 1, self ));
6483+ }
6484+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6485+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6486+ if (!SWIG_IsOK(ecode2)) {
6487+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","NSYMBT", 2, argv[0] ));
6488+ }
6489+ arg2 = (mrcImageParaTypeInteger)(val2);
6490+ if (arg1) (arg1)->NSYMBT = arg2;
6491+ return Qnil;
6492+fail:
6493+ return Qnil;
6494+}
6495+
6496+
6497+SWIGINTERN VALUE
6498+_wrap__mrcImageHeaderCCP4_NSYMBT_get(int argc, VALUE *argv, VALUE self) {
6499+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6500+ void *argp1 = 0 ;
6501+ int res1 = 0 ;
6502+ mrcImageParaTypeInteger result;
6503+ VALUE vresult = Qnil;
6504+
6505+ if ((argc < 0) || (argc > 0)) {
6506+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6507+ }
6508+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6509+ if (!SWIG_IsOK(res1)) {
6510+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","NSYMBT", 1, self ));
6511+ }
6512+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6513+ result = (mrcImageParaTypeInteger) ((arg1)->NSYMBT);
6514+ vresult = SWIG_From_int((int)(result));
6515+ return vresult;
6516+fail:
6517+ return Qnil;
6518+}
6519+
6520+
6521+SWIGINTERN VALUE
6522+_wrap__mrcImageHeaderCCP4_LSKFLG_set(int argc, VALUE *argv, VALUE self) {
6523+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6524+ mrcImageParaTypeInteger arg2 ;
6525+ void *argp1 = 0 ;
6526+ int res1 = 0 ;
6527+ int val2 ;
6528+ int ecode2 = 0 ;
6529+
6530+ if ((argc < 1) || (argc > 1)) {
6531+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6532+ }
6533+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6534+ if (!SWIG_IsOK(res1)) {
6535+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","LSKFLG", 1, self ));
6536+ }
6537+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6538+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6539+ if (!SWIG_IsOK(ecode2)) {
6540+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","LSKFLG", 2, argv[0] ));
6541+ }
6542+ arg2 = (mrcImageParaTypeInteger)(val2);
6543+ if (arg1) (arg1)->LSKFLG = arg2;
6544+ return Qnil;
6545+fail:
6546+ return Qnil;
6547+}
6548+
6549+
6550+SWIGINTERN VALUE
6551+_wrap__mrcImageHeaderCCP4_LSKFLG_get(int argc, VALUE *argv, VALUE self) {
6552+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6553+ void *argp1 = 0 ;
6554+ int res1 = 0 ;
6555+ mrcImageParaTypeInteger result;
6556+ VALUE vresult = Qnil;
6557+
6558+ if ((argc < 0) || (argc > 0)) {
6559+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6560+ }
6561+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6562+ if (!SWIG_IsOK(res1)) {
6563+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","LSKFLG", 1, self ));
6564+ }
6565+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6566+ result = (mrcImageParaTypeInteger) ((arg1)->LSKFLG);
6567+ vresult = SWIG_From_int((int)(result));
6568+ return vresult;
6569+fail:
6570+ return Qnil;
6571+}
6572+
6573+
6574+SWIGINTERN VALUE
6575+_wrap__mrcImageHeaderCCP4_SKWMAT_set(int argc, VALUE *argv, VALUE self) {
6576+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6577+ mrcImageParaTypeReal *arg2 ;
6578+ void *argp1 = 0 ;
6579+ int res1 = 0 ;
6580+ void *argp2 = 0 ;
6581+ int res2 = 0 ;
6582+
6583+ if ((argc < 1) || (argc > 1)) {
6584+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6585+ }
6586+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6587+ if (!SWIG_IsOK(res1)) {
6588+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","SKWMAT", 1, self ));
6589+ }
6590+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6591+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
6592+ if (!SWIG_IsOK(res2)) {
6593+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [9]","SKWMAT", 2, argv[0] ));
6594+ }
6595+ arg2 = (mrcImageParaTypeReal *)(argp2);
6596+ {
6597+ if (arg2) {
6598+ size_t ii = 0;
6599+ for (; ii < (size_t)9; ++ii) arg1->SKWMAT[ii] = arg2[ii];
6600+ } else {
6601+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""SKWMAT""' of type '""mrcImageParaTypeReal [9]""'");
6602+ }
6603+ }
6604+ return Qnil;
6605+fail:
6606+ return Qnil;
6607+}
6608+
6609+
6610+SWIGINTERN VALUE
6611+_wrap__mrcImageHeaderCCP4_SKWMAT_get(int argc, VALUE *argv, VALUE self) {
6612+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6613+ void *argp1 = 0 ;
6614+ int res1 = 0 ;
6615+ mrcImageParaTypeReal *result = 0 ;
6616+ VALUE vresult = Qnil;
6617+
6618+ if ((argc < 0) || (argc > 0)) {
6619+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6620+ }
6621+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6622+ if (!SWIG_IsOK(res1)) {
6623+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","SKWMAT", 1, self ));
6624+ }
6625+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6626+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->SKWMAT);
6627+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
6628+ return vresult;
6629+fail:
6630+ return Qnil;
6631+}
6632+
6633+
6634+SWIGINTERN VALUE
6635+_wrap__mrcImageHeaderCCP4_SKWTRN_set(int argc, VALUE *argv, VALUE self) {
6636+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6637+ mrcImageParaTypeReal *arg2 ;
6638+ void *argp1 = 0 ;
6639+ int res1 = 0 ;
6640+ void *argp2 = 0 ;
6641+ int res2 = 0 ;
6642+
6643+ if ((argc < 1) || (argc > 1)) {
6644+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6645+ }
6646+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6647+ if (!SWIG_IsOK(res1)) {
6648+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","SKWTRN", 1, self ));
6649+ }
6650+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6651+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
6652+ if (!SWIG_IsOK(res2)) {
6653+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [3]","SKWTRN", 2, argv[0] ));
6654+ }
6655+ arg2 = (mrcImageParaTypeReal *)(argp2);
6656+ {
6657+ if (arg2) {
6658+ size_t ii = 0;
6659+ for (; ii < (size_t)3; ++ii) arg1->SKWTRN[ii] = arg2[ii];
6660+ } else {
6661+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""SKWTRN""' of type '""mrcImageParaTypeReal [3]""'");
6662+ }
6663+ }
6664+ return Qnil;
6665+fail:
6666+ return Qnil;
6667+}
6668+
6669+
6670+SWIGINTERN VALUE
6671+_wrap__mrcImageHeaderCCP4_SKWTRN_get(int argc, VALUE *argv, VALUE self) {
6672+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6673+ void *argp1 = 0 ;
6674+ int res1 = 0 ;
6675+ mrcImageParaTypeReal *result = 0 ;
6676+ VALUE vresult = Qnil;
6677+
6678+ if ((argc < 0) || (argc > 0)) {
6679+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6680+ }
6681+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6682+ if (!SWIG_IsOK(res1)) {
6683+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","SKWTRN", 1, self ));
6684+ }
6685+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6686+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->SKWTRN);
6687+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
6688+ return vresult;
6689+fail:
6690+ return Qnil;
6691+}
6692+
6693+
6694+SWIGINTERN VALUE
6695+_wrap__mrcImageHeaderCCP4_EXTRA_set(int argc, VALUE *argv, VALUE self) {
6696+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6697+ mrcImageParaTypeReal *arg2 ;
6698+ void *argp1 = 0 ;
6699+ int res1 = 0 ;
6700+ void *argp2 = 0 ;
6701+ int res2 = 0 ;
6702+
6703+ if ((argc < 1) || (argc > 1)) {
6704+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6705+ }
6706+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6707+ if (!SWIG_IsOK(res1)) {
6708+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","EXTRA", 1, self ));
6709+ }
6710+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6711+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
6712+ if (!SWIG_IsOK(res2)) {
6713+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [(15)]","EXTRA", 2, argv[0] ));
6714+ }
6715+ arg2 = (mrcImageParaTypeReal *)(argp2);
6716+ {
6717+ if (arg2) {
6718+ size_t ii = 0;
6719+ for (; ii < (size_t)(15); ++ii) arg1->EXTRA[ii] = arg2[ii];
6720+ } else {
6721+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""EXTRA""' of type '""mrcImageParaTypeReal [(15)]""'");
6722+ }
6723+ }
6724+ return Qnil;
6725+fail:
6726+ return Qnil;
6727+}
6728+
6729+
6730+SWIGINTERN VALUE
6731+_wrap__mrcImageHeaderCCP4_EXTRA_get(int argc, VALUE *argv, VALUE self) {
6732+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6733+ void *argp1 = 0 ;
6734+ int res1 = 0 ;
6735+ mrcImageParaTypeReal *result = 0 ;
6736+ VALUE vresult = Qnil;
6737+
6738+ if ((argc < 0) || (argc > 0)) {
6739+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6740+ }
6741+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6742+ if (!SWIG_IsOK(res1)) {
6743+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","EXTRA", 1, self ));
6744+ }
6745+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6746+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->EXTRA);
6747+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
6748+ return vresult;
6749+fail:
6750+ return Qnil;
6751+}
6752+
6753+
6754+SWIGINTERN VALUE
6755+_wrap__mrcImageHeaderCCP4_MAP_set(int argc, VALUE *argv, VALUE self) {
6756+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6757+ mrcImageParaTypeCharacter *arg2 ;
6758+ void *argp1 = 0 ;
6759+ int res1 = 0 ;
6760+ void *argp2 = 0 ;
6761+ int res2 = 0 ;
6762+
6763+ if ((argc < 1) || (argc > 1)) {
6764+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6765+ }
6766+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6767+ if (!SWIG_IsOK(res1)) {
6768+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MAP", 1, self ));
6769+ }
6770+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6771+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
6772+ if (!SWIG_IsOK(res2)) {
6773+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeCharacter [4]","MAP", 2, argv[0] ));
6774+ }
6775+ arg2 = (mrcImageParaTypeCharacter *)(argp2);
6776+ {
6777+ if (arg2) {
6778+ size_t ii = 0;
6779+ for (; ii < (size_t)4; ++ii) arg1->MAP[ii] = arg2[ii];
6780+ } else {
6781+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""MAP""' of type '""mrcImageParaTypeCharacter [4]""'");
6782+ }
6783+ }
6784+ return Qnil;
6785+fail:
6786+ return Qnil;
6787+}
6788+
6789+
6790+SWIGINTERN VALUE
6791+_wrap__mrcImageHeaderCCP4_MAP_get(int argc, VALUE *argv, VALUE self) {
6792+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6793+ void *argp1 = 0 ;
6794+ int res1 = 0 ;
6795+ mrcImageParaTypeCharacter *result = 0 ;
6796+ VALUE vresult = Qnil;
6797+
6798+ if ((argc < 0) || (argc > 0)) {
6799+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6800+ }
6801+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6802+ if (!SWIG_IsOK(res1)) {
6803+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MAP", 1, self ));
6804+ }
6805+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6806+ result = (mrcImageParaTypeCharacter *)(mrcImageParaTypeCharacter *) ((arg1)->MAP);
6807+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
6808+ return vresult;
6809+fail:
6810+ return Qnil;
6811+}
6812+
6813+
6814+SWIGINTERN VALUE
6815+_wrap__mrcImageHeaderCCP4_MARCHST_set(int argc, VALUE *argv, VALUE self) {
6816+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6817+ mrcImageParaTypeInteger arg2 ;
6818+ void *argp1 = 0 ;
6819+ int res1 = 0 ;
6820+ int val2 ;
6821+ int ecode2 = 0 ;
6822+
6823+ if ((argc < 1) || (argc > 1)) {
6824+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6825+ }
6826+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6827+ if (!SWIG_IsOK(res1)) {
6828+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MARCHST", 1, self ));
6829+ }
6830+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6831+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6832+ if (!SWIG_IsOK(ecode2)) {
6833+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MARCHST", 2, argv[0] ));
6834+ }
6835+ arg2 = (mrcImageParaTypeInteger)(val2);
6836+ if (arg1) (arg1)->MARCHST = arg2;
6837+ return Qnil;
6838+fail:
6839+ return Qnil;
6840+}
6841+
6842+
6843+SWIGINTERN VALUE
6844+_wrap__mrcImageHeaderCCP4_MARCHST_get(int argc, VALUE *argv, VALUE self) {
6845+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6846+ void *argp1 = 0 ;
6847+ int res1 = 0 ;
6848+ mrcImageParaTypeInteger result;
6849+ VALUE vresult = Qnil;
6850+
6851+ if ((argc < 0) || (argc > 0)) {
6852+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6853+ }
6854+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6855+ if (!SWIG_IsOK(res1)) {
6856+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","MARCHST", 1, self ));
6857+ }
6858+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6859+ result = (mrcImageParaTypeInteger) ((arg1)->MARCHST);
6860+ vresult = SWIG_From_int((int)(result));
6861+ return vresult;
6862+fail:
6863+ return Qnil;
6864+}
6865+
6866+
6867+SWIGINTERN VALUE
6868+_wrap__mrcImageHeaderCCP4_ARMS_set(int argc, VALUE *argv, VALUE self) {
6869+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6870+ mrcImageParaTypeReal arg2 ;
6871+ void *argp1 = 0 ;
6872+ int res1 = 0 ;
6873+ float val2 ;
6874+ int ecode2 = 0 ;
6875+
6876+ if ((argc < 1) || (argc > 1)) {
6877+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6878+ }
6879+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6880+ if (!SWIG_IsOK(res1)) {
6881+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","ARMS", 1, self ));
6882+ }
6883+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6884+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
6885+ if (!SWIG_IsOK(ecode2)) {
6886+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","ARMS", 2, argv[0] ));
6887+ }
6888+ arg2 = (mrcImageParaTypeReal)(val2);
6889+ if (arg1) (arg1)->ARMS = arg2;
6890+ return Qnil;
6891+fail:
6892+ return Qnil;
6893+}
6894+
6895+
6896+SWIGINTERN VALUE
6897+_wrap__mrcImageHeaderCCP4_ARMS_get(int argc, VALUE *argv, VALUE self) {
6898+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6899+ void *argp1 = 0 ;
6900+ int res1 = 0 ;
6901+ mrcImageParaTypeReal result;
6902+ VALUE vresult = Qnil;
6903+
6904+ if ((argc < 0) || (argc > 0)) {
6905+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6906+ }
6907+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6908+ if (!SWIG_IsOK(res1)) {
6909+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","ARMS", 1, self ));
6910+ }
6911+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6912+ result = (mrcImageParaTypeReal) ((arg1)->ARMS);
6913+ vresult = SWIG_From_float((float)(result));
6914+ return vresult;
6915+fail:
6916+ return Qnil;
6917+}
6918+
6919+
6920+SWIGINTERN VALUE
6921+_wrap__mrcImageHeaderCCP4_LabelN_set(int argc, VALUE *argv, VALUE self) {
6922+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6923+ mrcImageParaTypeInteger arg2 ;
6924+ void *argp1 = 0 ;
6925+ int res1 = 0 ;
6926+ int val2 ;
6927+ int ecode2 = 0 ;
6928+
6929+ if ((argc < 1) || (argc > 1)) {
6930+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6931+ }
6932+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6933+ if (!SWIG_IsOK(res1)) {
6934+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","LabelN", 1, self ));
6935+ }
6936+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6937+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
6938+ if (!SWIG_IsOK(ecode2)) {
6939+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","LabelN", 2, argv[0] ));
6940+ }
6941+ arg2 = (mrcImageParaTypeInteger)(val2);
6942+ if (arg1) (arg1)->LabelN = arg2;
6943+ return Qnil;
6944+fail:
6945+ return Qnil;
6946+}
6947+
6948+
6949+SWIGINTERN VALUE
6950+_wrap__mrcImageHeaderCCP4_LabelN_get(int argc, VALUE *argv, VALUE self) {
6951+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6952+ void *argp1 = 0 ;
6953+ int res1 = 0 ;
6954+ mrcImageParaTypeInteger result;
6955+ VALUE vresult = Qnil;
6956+
6957+ if ((argc < 0) || (argc > 0)) {
6958+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
6959+ }
6960+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6961+ if (!SWIG_IsOK(res1)) {
6962+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","LabelN", 1, self ));
6963+ }
6964+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6965+ result = (mrcImageParaTypeInteger) ((arg1)->LabelN);
6966+ vresult = SWIG_From_int((int)(result));
6967+ return vresult;
6968+fail:
6969+ return Qnil;
6970+}
6971+
6972+
6973+SWIGINTERN VALUE
6974+_wrap__mrcImageHeaderCCP4_Label_set(int argc, VALUE *argv, VALUE self) {
6975+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
6976+ char (*arg2)[(80)] ;
6977+ void *argp1 = 0 ;
6978+ int res1 = 0 ;
6979+ void *argp2 = 0 ;
6980+ int res2 = 0 ;
6981+
6982+ if ((argc < 1) || (argc > 1)) {
6983+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
6984+ }
6985+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
6986+ if (!SWIG_IsOK(res1)) {
6987+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Label", 1, self ));
6988+ }
6989+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
6990+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_a__80___char, 0 | 0 );
6991+ if (!SWIG_IsOK(res2)) {
6992+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [(10)][(80)]","Label", 2, argv[0] ));
6993+ }
6994+ arg2 = (char (*)[(80)])(argp2);
6995+ {
6996+ if (arg2) {
6997+ size_t ii = 0;
6998+ for (; ii < (size_t)(10); ++ii) {
6999+ if (arg2[ii]) {
7000+ size_t jj = 0;
7001+ for (; jj < (size_t)(80); ++jj) arg1->Label[ii][jj] = arg2[ii][jj];
7002+ } else {
7003+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Label""' of type '""char [(10)][(80)]""'");
7004+ }
7005+ }
7006+ } else {
7007+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Label""' of type '""char [(10)][(80)]""'");
7008+ }
7009+ }
7010+ return Qnil;
7011+fail:
7012+ return Qnil;
7013+}
7014+
7015+
7016+SWIGINTERN VALUE
7017+_wrap__mrcImageHeaderCCP4_Label_get(int argc, VALUE *argv, VALUE self) {
7018+ _mrcImageHeaderCCP4 *arg1 = (_mrcImageHeaderCCP4 *) 0 ;
7019+ void *argp1 = 0 ;
7020+ int res1 = 0 ;
7021+ char (*result)[(80)] = 0 ;
7022+ VALUE vresult = Qnil;
7023+
7024+ if ((argc < 0) || (argc > 0)) {
7025+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7026+ }
7027+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
7028+ if (!SWIG_IsOK(res1)) {
7029+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","Label", 1, self ));
7030+ }
7031+ arg1 = (_mrcImageHeaderCCP4 *)(argp1);
7032+ result = (char (*)[(80)])(char (*)[(80)]) ((arg1)->Label);
7033+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a__80___char, 0 | 0 );
7034+ return vresult;
7035+fail:
7036+ return Qnil;
7037+}
7038+
7039+
7040+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
7041+SWIGINTERN VALUE
7042+_wrap__mrcImageHeaderCCP4_allocate(VALUE self) {
7043+#else
7044+ SWIGINTERN VALUE
7045+ _wrap__mrcImageHeaderCCP4_allocate(int argc, VALUE *argv, VALUE self) {
7046+#endif
7047+
7048+
7049+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p__mrcImageHeaderCCP4);
7050+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
7051+ rb_obj_call_init(vresult, argc, argv);
7052+#endif
7053+ return vresult;
7054+ }
7055+
7056+
7057+SWIGINTERN VALUE
7058+_wrap_new__mrcImageHeaderCCP4(int argc, VALUE *argv, VALUE self) {
7059+ _mrcImageHeaderCCP4 *result = 0 ;
7060+
7061+ if ((argc < 0) || (argc > 0)) {
7062+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7063+ }
7064+ result = (_mrcImageHeaderCCP4 *)calloc(1, sizeof(_mrcImageHeaderCCP4));
7065+ DATA_PTR(self) = result;
7066+ return self;
7067+fail:
7068+ return Qnil;
7069+}
7070+
7071+
7072+SWIGINTERN void
7073+free__mrcImageHeaderCCP4(_mrcImageHeaderCCP4 *arg1) {
7074+ free((char *) arg1);
7075+}
7076+
7077+swig_class SwigClass_mrcImageHeaderIMOD;
7078+
7079+SWIGINTERN VALUE
7080+_wrap__mrcImageHeaderIMOD_N_set(int argc, VALUE *argv, VALUE self) {
7081+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7082+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
7083+ void *argp1 = 0 ;
7084+ int res1 = 0 ;
7085+ void *argp2 = 0 ;
7086+ int res2 = 0 ;
7087+
7088+ if ((argc < 1) || (argc > 1)) {
7089+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7090+ }
7091+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7092+ if (!SWIG_IsOK(res1)) {
7093+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","N", 1, self ));
7094+ }
7095+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7096+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
7097+ if (!SWIG_IsOK(res2)) {
7098+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","N", 2, argv[0] ));
7099+ }
7100+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
7101+ if (arg1) (arg1)->N = *arg2;
7102+ return Qnil;
7103+fail:
7104+ return Qnil;
7105+}
7106+
7107+
7108+SWIGINTERN VALUE
7109+_wrap__mrcImageHeaderIMOD_N_get(int argc, VALUE *argv, VALUE self) {
7110+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7111+ void *argp1 = 0 ;
7112+ int res1 = 0 ;
7113+ mrcImageParaTypeIntegerCoord *result = 0 ;
7114+ VALUE vresult = Qnil;
7115+
7116+ if ((argc < 0) || (argc > 0)) {
7117+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7118+ }
7119+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7120+ if (!SWIG_IsOK(res1)) {
7121+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","N", 1, self ));
7122+ }
7123+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7124+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->N);
7125+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
7126+ return vresult;
7127+fail:
7128+ return Qnil;
7129+}
7130+
7131+
7132+SWIGINTERN VALUE
7133+_wrap__mrcImageHeaderIMOD_Mode_set(int argc, VALUE *argv, VALUE self) {
7134+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7135+ mrcImageMode arg2 ;
7136+ void *argp1 = 0 ;
7137+ int res1 = 0 ;
7138+ int val2 ;
7139+ int ecode2 = 0 ;
7140+
7141+ if ((argc < 1) || (argc > 1)) {
7142+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7143+ }
7144+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7145+ if (!SWIG_IsOK(res1)) {
7146+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Mode", 1, self ));
7147+ }
7148+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7149+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
7150+ if (!SWIG_IsOK(ecode2)) {
7151+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageMode","Mode", 2, argv[0] ));
7152+ }
7153+ arg2 = (mrcImageMode)(val2);
7154+ if (arg1) (arg1)->Mode = arg2;
7155+ return Qnil;
7156+fail:
7157+ return Qnil;
7158+}
7159+
7160+
7161+SWIGINTERN VALUE
7162+_wrap__mrcImageHeaderIMOD_Mode_get(int argc, VALUE *argv, VALUE self) {
7163+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7164+ void *argp1 = 0 ;
7165+ int res1 = 0 ;
7166+ mrcImageMode result;
7167+ VALUE vresult = Qnil;
7168+
7169+ if ((argc < 0) || (argc > 0)) {
7170+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7171+ }
7172+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7173+ if (!SWIG_IsOK(res1)) {
7174+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Mode", 1, self ));
7175+ }
7176+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7177+ result = (mrcImageMode) ((arg1)->Mode);
7178+ vresult = SWIG_From_int((int)(result));
7179+ return vresult;
7180+fail:
7181+ return Qnil;
7182+}
7183+
7184+
7185+SWIGINTERN VALUE
7186+_wrap__mrcImageHeaderIMOD_StartN_set(int argc, VALUE *argv, VALUE self) {
7187+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7188+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
7189+ void *argp1 = 0 ;
7190+ int res1 = 0 ;
7191+ void *argp2 = 0 ;
7192+ int res2 = 0 ;
7193+
7194+ if ((argc < 1) || (argc > 1)) {
7195+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7196+ }
7197+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7198+ if (!SWIG_IsOK(res1)) {
7199+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","StartN", 1, self ));
7200+ }
7201+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7202+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
7203+ if (!SWIG_IsOK(res2)) {
7204+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","StartN", 2, argv[0] ));
7205+ }
7206+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
7207+ if (arg1) (arg1)->StartN = *arg2;
7208+ return Qnil;
7209+fail:
7210+ return Qnil;
7211+}
7212+
7213+
7214+SWIGINTERN VALUE
7215+_wrap__mrcImageHeaderIMOD_StartN_get(int argc, VALUE *argv, VALUE self) {
7216+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7217+ void *argp1 = 0 ;
7218+ int res1 = 0 ;
7219+ mrcImageParaTypeIntegerCoord *result = 0 ;
7220+ VALUE vresult = Qnil;
7221+
7222+ if ((argc < 0) || (argc > 0)) {
7223+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7224+ }
7225+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7226+ if (!SWIG_IsOK(res1)) {
7227+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","StartN", 1, self ));
7228+ }
7229+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7230+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->StartN);
7231+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
7232+ return vresult;
7233+fail:
7234+ return Qnil;
7235+}
7236+
7237+
7238+SWIGINTERN VALUE
7239+_wrap__mrcImageHeaderIMOD_M_set(int argc, VALUE *argv, VALUE self) {
7240+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7241+ mrcImageParaTypeIntegerCoord *arg2 = (mrcImageParaTypeIntegerCoord *) 0 ;
7242+ void *argp1 = 0 ;
7243+ int res1 = 0 ;
7244+ void *argp2 = 0 ;
7245+ int res2 = 0 ;
7246+
7247+ if ((argc < 1) || (argc > 1)) {
7248+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7249+ }
7250+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7251+ if (!SWIG_IsOK(res1)) {
7252+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","M", 1, self ));
7253+ }
7254+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7255+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
7256+ if (!SWIG_IsOK(res2)) {
7257+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeIntegerCoord *","M", 2, argv[0] ));
7258+ }
7259+ arg2 = (mrcImageParaTypeIntegerCoord *)(argp2);
7260+ if (arg1) (arg1)->M = *arg2;
7261+ return Qnil;
7262+fail:
7263+ return Qnil;
7264+}
7265+
7266+
7267+SWIGINTERN VALUE
7268+_wrap__mrcImageHeaderIMOD_M_get(int argc, VALUE *argv, VALUE self) {
7269+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7270+ void *argp1 = 0 ;
7271+ int res1 = 0 ;
7272+ mrcImageParaTypeIntegerCoord *result = 0 ;
7273+ VALUE vresult = Qnil;
7274+
7275+ if ((argc < 0) || (argc > 0)) {
7276+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7277+ }
7278+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7279+ if (!SWIG_IsOK(res1)) {
7280+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","M", 1, self ));
7281+ }
7282+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7283+ result = (mrcImageParaTypeIntegerCoord *)& ((arg1)->M);
7284+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeIntegerCoord, 0 | 0 );
7285+ return vresult;
7286+fail:
7287+ return Qnil;
7288+}
7289+
7290+
7291+SWIGINTERN VALUE
7292+_wrap__mrcImageHeaderIMOD_Length_set(int argc, VALUE *argv, VALUE self) {
7293+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7294+ mrcImageParaTypeRealCoord *arg2 = (mrcImageParaTypeRealCoord *) 0 ;
7295+ void *argp1 = 0 ;
7296+ int res1 = 0 ;
7297+ void *argp2 = 0 ;
7298+ int res2 = 0 ;
7299+
7300+ if ((argc < 1) || (argc > 1)) {
7301+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7302+ }
7303+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7304+ if (!SWIG_IsOK(res1)) {
7305+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Length", 1, self ));
7306+ }
7307+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7308+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
7309+ if (!SWIG_IsOK(res2)) {
7310+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","Length", 2, argv[0] ));
7311+ }
7312+ arg2 = (mrcImageParaTypeRealCoord *)(argp2);
7313+ if (arg1) (arg1)->Length = *arg2;
7314+ return Qnil;
7315+fail:
7316+ return Qnil;
7317+}
7318+
7319+
7320+SWIGINTERN VALUE
7321+_wrap__mrcImageHeaderIMOD_Length_get(int argc, VALUE *argv, VALUE self) {
7322+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7323+ void *argp1 = 0 ;
7324+ int res1 = 0 ;
7325+ mrcImageParaTypeRealCoord *result = 0 ;
7326+ VALUE vresult = Qnil;
7327+
7328+ if ((argc < 0) || (argc > 0)) {
7329+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7330+ }
7331+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7332+ if (!SWIG_IsOK(res1)) {
7333+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Length", 1, self ));
7334+ }
7335+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7336+ result = (mrcImageParaTypeRealCoord *)& ((arg1)->Length);
7337+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
7338+ return vresult;
7339+fail:
7340+ return Qnil;
7341+}
7342+
7343+
7344+SWIGINTERN VALUE
7345+_wrap__mrcImageHeaderIMOD_Alpha_set(int argc, VALUE *argv, VALUE self) {
7346+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7347+ mrcImageParaTypeReal arg2 ;
7348+ void *argp1 = 0 ;
7349+ int res1 = 0 ;
7350+ float val2 ;
7351+ int ecode2 = 0 ;
7352+
7353+ if ((argc < 1) || (argc > 1)) {
7354+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7355+ }
7356+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7357+ if (!SWIG_IsOK(res1)) {
7358+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Alpha", 1, self ));
7359+ }
7360+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7361+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
7362+ if (!SWIG_IsOK(ecode2)) {
7363+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Alpha", 2, argv[0] ));
7364+ }
7365+ arg2 = (mrcImageParaTypeReal)(val2);
7366+ if (arg1) (arg1)->Alpha = arg2;
7367+ return Qnil;
7368+fail:
7369+ return Qnil;
7370+}
7371+
7372+
7373+SWIGINTERN VALUE
7374+_wrap__mrcImageHeaderIMOD_Alpha_get(int argc, VALUE *argv, VALUE self) {
7375+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7376+ void *argp1 = 0 ;
7377+ int res1 = 0 ;
7378+ mrcImageParaTypeReal result;
7379+ VALUE vresult = Qnil;
7380+
7381+ if ((argc < 0) || (argc > 0)) {
7382+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7383+ }
7384+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7385+ if (!SWIG_IsOK(res1)) {
7386+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Alpha", 1, self ));
7387+ }
7388+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7389+ result = (mrcImageParaTypeReal) ((arg1)->Alpha);
7390+ vresult = SWIG_From_float((float)(result));
7391+ return vresult;
7392+fail:
7393+ return Qnil;
7394+}
7395+
7396+
7397+SWIGINTERN VALUE
7398+_wrap__mrcImageHeaderIMOD_Beta_set(int argc, VALUE *argv, VALUE self) {
7399+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7400+ mrcImageParaTypeReal arg2 ;
7401+ void *argp1 = 0 ;
7402+ int res1 = 0 ;
7403+ float val2 ;
7404+ int ecode2 = 0 ;
7405+
7406+ if ((argc < 1) || (argc > 1)) {
7407+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7408+ }
7409+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7410+ if (!SWIG_IsOK(res1)) {
7411+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Beta", 1, self ));
7412+ }
7413+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7414+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
7415+ if (!SWIG_IsOK(ecode2)) {
7416+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Beta", 2, argv[0] ));
7417+ }
7418+ arg2 = (mrcImageParaTypeReal)(val2);
7419+ if (arg1) (arg1)->Beta = arg2;
7420+ return Qnil;
7421+fail:
7422+ return Qnil;
7423+}
7424+
7425+
7426+SWIGINTERN VALUE
7427+_wrap__mrcImageHeaderIMOD_Beta_get(int argc, VALUE *argv, VALUE self) {
7428+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7429+ void *argp1 = 0 ;
7430+ int res1 = 0 ;
7431+ mrcImageParaTypeReal result;
7432+ VALUE vresult = Qnil;
7433+
7434+ if ((argc < 0) || (argc > 0)) {
7435+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7436+ }
7437+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7438+ if (!SWIG_IsOK(res1)) {
7439+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Beta", 1, self ));
7440+ }
7441+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7442+ result = (mrcImageParaTypeReal) ((arg1)->Beta);
7443+ vresult = SWIG_From_float((float)(result));
7444+ return vresult;
7445+fail:
7446+ return Qnil;
7447+}
7448+
7449+
7450+SWIGINTERN VALUE
7451+_wrap__mrcImageHeaderIMOD_Gamma_set(int argc, VALUE *argv, VALUE self) {
7452+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7453+ mrcImageParaTypeReal arg2 ;
7454+ void *argp1 = 0 ;
7455+ int res1 = 0 ;
7456+ float val2 ;
7457+ int ecode2 = 0 ;
7458+
7459+ if ((argc < 1) || (argc > 1)) {
7460+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7461+ }
7462+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7463+ if (!SWIG_IsOK(res1)) {
7464+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Gamma", 1, self ));
7465+ }
7466+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7467+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
7468+ if (!SWIG_IsOK(ecode2)) {
7469+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Gamma", 2, argv[0] ));
7470+ }
7471+ arg2 = (mrcImageParaTypeReal)(val2);
7472+ if (arg1) (arg1)->Gamma = arg2;
7473+ return Qnil;
7474+fail:
7475+ return Qnil;
7476+}
7477+
7478+
7479+SWIGINTERN VALUE
7480+_wrap__mrcImageHeaderIMOD_Gamma_get(int argc, VALUE *argv, VALUE self) {
7481+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7482+ void *argp1 = 0 ;
7483+ int res1 = 0 ;
7484+ mrcImageParaTypeReal result;
7485+ VALUE vresult = Qnil;
7486+
7487+ if ((argc < 0) || (argc > 0)) {
7488+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7489+ }
7490+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7491+ if (!SWIG_IsOK(res1)) {
7492+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Gamma", 1, self ));
7493+ }
7494+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7495+ result = (mrcImageParaTypeReal) ((arg1)->Gamma);
7496+ vresult = SWIG_From_float((float)(result));
7497+ return vresult;
7498+fail:
7499+ return Qnil;
7500+}
7501+
7502+
7503+SWIGINTERN VALUE
7504+_wrap__mrcImageHeaderIMOD_MAPC_set(int argc, VALUE *argv, VALUE self) {
7505+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7506+ mrcImageParaTypeInteger arg2 ;
7507+ void *argp1 = 0 ;
7508+ int res1 = 0 ;
7509+ int val2 ;
7510+ int ecode2 = 0 ;
7511+
7512+ if ((argc < 1) || (argc > 1)) {
7513+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7514+ }
7515+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7516+ if (!SWIG_IsOK(res1)) {
7517+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MAPC", 1, self ));
7518+ }
7519+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7520+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
7521+ if (!SWIG_IsOK(ecode2)) {
7522+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPC", 2, argv[0] ));
7523+ }
7524+ arg2 = (mrcImageParaTypeInteger)(val2);
7525+ if (arg1) (arg1)->MAPC = arg2;
7526+ return Qnil;
7527+fail:
7528+ return Qnil;
7529+}
7530+
7531+
7532+SWIGINTERN VALUE
7533+_wrap__mrcImageHeaderIMOD_MAPC_get(int argc, VALUE *argv, VALUE self) {
7534+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7535+ void *argp1 = 0 ;
7536+ int res1 = 0 ;
7537+ mrcImageParaTypeInteger result;
7538+ VALUE vresult = Qnil;
7539+
7540+ if ((argc < 0) || (argc > 0)) {
7541+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7542+ }
7543+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7544+ if (!SWIG_IsOK(res1)) {
7545+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MAPC", 1, self ));
7546+ }
7547+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7548+ result = (mrcImageParaTypeInteger) ((arg1)->MAPC);
7549+ vresult = SWIG_From_int((int)(result));
7550+ return vresult;
7551+fail:
7552+ return Qnil;
7553+}
7554+
7555+
7556+SWIGINTERN VALUE
7557+_wrap__mrcImageHeaderIMOD_MAPR_set(int argc, VALUE *argv, VALUE self) {
7558+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7559+ mrcImageParaTypeInteger arg2 ;
7560+ void *argp1 = 0 ;
7561+ int res1 = 0 ;
7562+ int val2 ;
7563+ int ecode2 = 0 ;
7564+
7565+ if ((argc < 1) || (argc > 1)) {
7566+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7567+ }
7568+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7569+ if (!SWIG_IsOK(res1)) {
7570+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MAPR", 1, self ));
7571+ }
7572+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7573+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
7574+ if (!SWIG_IsOK(ecode2)) {
7575+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPR", 2, argv[0] ));
7576+ }
7577+ arg2 = (mrcImageParaTypeInteger)(val2);
7578+ if (arg1) (arg1)->MAPR = arg2;
7579+ return Qnil;
7580+fail:
7581+ return Qnil;
7582+}
7583+
7584+
7585+SWIGINTERN VALUE
7586+_wrap__mrcImageHeaderIMOD_MAPR_get(int argc, VALUE *argv, VALUE self) {
7587+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7588+ void *argp1 = 0 ;
7589+ int res1 = 0 ;
7590+ mrcImageParaTypeInteger result;
7591+ VALUE vresult = Qnil;
7592+
7593+ if ((argc < 0) || (argc > 0)) {
7594+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7595+ }
7596+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7597+ if (!SWIG_IsOK(res1)) {
7598+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MAPR", 1, self ));
7599+ }
7600+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7601+ result = (mrcImageParaTypeInteger) ((arg1)->MAPR);
7602+ vresult = SWIG_From_int((int)(result));
7603+ return vresult;
7604+fail:
7605+ return Qnil;
7606+}
7607+
7608+
7609+SWIGINTERN VALUE
7610+_wrap__mrcImageHeaderIMOD_MAPS_set(int argc, VALUE *argv, VALUE self) {
7611+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7612+ mrcImageParaTypeInteger arg2 ;
7613+ void *argp1 = 0 ;
7614+ int res1 = 0 ;
7615+ int val2 ;
7616+ int ecode2 = 0 ;
7617+
7618+ if ((argc < 1) || (argc > 1)) {
7619+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7620+ }
7621+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7622+ if (!SWIG_IsOK(res1)) {
7623+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MAPS", 1, self ));
7624+ }
7625+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7626+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
7627+ if (!SWIG_IsOK(ecode2)) {
7628+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MAPS", 2, argv[0] ));
7629+ }
7630+ arg2 = (mrcImageParaTypeInteger)(val2);
7631+ if (arg1) (arg1)->MAPS = arg2;
7632+ return Qnil;
7633+fail:
7634+ return Qnil;
7635+}
7636+
7637+
7638+SWIGINTERN VALUE
7639+_wrap__mrcImageHeaderIMOD_MAPS_get(int argc, VALUE *argv, VALUE self) {
7640+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7641+ void *argp1 = 0 ;
7642+ int res1 = 0 ;
7643+ mrcImageParaTypeInteger result;
7644+ VALUE vresult = Qnil;
7645+
7646+ if ((argc < 0) || (argc > 0)) {
7647+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7648+ }
7649+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7650+ if (!SWIG_IsOK(res1)) {
7651+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MAPS", 1, self ));
7652+ }
7653+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7654+ result = (mrcImageParaTypeInteger) ((arg1)->MAPS);
7655+ vresult = SWIG_From_int((int)(result));
7656+ return vresult;
7657+fail:
7658+ return Qnil;
7659+}
7660+
7661+
7662+SWIGINTERN VALUE
7663+_wrap__mrcImageHeaderIMOD_AMin_set(int argc, VALUE *argv, VALUE self) {
7664+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7665+ mrcImageParaTypeReal arg2 ;
7666+ void *argp1 = 0 ;
7667+ int res1 = 0 ;
7668+ float val2 ;
7669+ int ecode2 = 0 ;
7670+
7671+ if ((argc < 1) || (argc > 1)) {
7672+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7673+ }
7674+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7675+ if (!SWIG_IsOK(res1)) {
7676+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","AMin", 1, self ));
7677+ }
7678+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7679+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
7680+ if (!SWIG_IsOK(ecode2)) {
7681+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMin", 2, argv[0] ));
7682+ }
7683+ arg2 = (mrcImageParaTypeReal)(val2);
7684+ if (arg1) (arg1)->AMin = arg2;
7685+ return Qnil;
7686+fail:
7687+ return Qnil;
7688+}
7689+
7690+
7691+SWIGINTERN VALUE
7692+_wrap__mrcImageHeaderIMOD_AMin_get(int argc, VALUE *argv, VALUE self) {
7693+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7694+ void *argp1 = 0 ;
7695+ int res1 = 0 ;
7696+ mrcImageParaTypeReal result;
7697+ VALUE vresult = Qnil;
7698+
7699+ if ((argc < 0) || (argc > 0)) {
7700+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7701+ }
7702+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7703+ if (!SWIG_IsOK(res1)) {
7704+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","AMin", 1, self ));
7705+ }
7706+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7707+ result = (mrcImageParaTypeReal) ((arg1)->AMin);
7708+ vresult = SWIG_From_float((float)(result));
7709+ return vresult;
7710+fail:
7711+ return Qnil;
7712+}
7713+
7714+
7715+SWIGINTERN VALUE
7716+_wrap__mrcImageHeaderIMOD_AMax_set(int argc, VALUE *argv, VALUE self) {
7717+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7718+ mrcImageParaTypeReal arg2 ;
7719+ void *argp1 = 0 ;
7720+ int res1 = 0 ;
7721+ float val2 ;
7722+ int ecode2 = 0 ;
7723+
7724+ if ((argc < 1) || (argc > 1)) {
7725+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7726+ }
7727+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7728+ if (!SWIG_IsOK(res1)) {
7729+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","AMax", 1, self ));
7730+ }
7731+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7732+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
7733+ if (!SWIG_IsOK(ecode2)) {
7734+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMax", 2, argv[0] ));
7735+ }
7736+ arg2 = (mrcImageParaTypeReal)(val2);
7737+ if (arg1) (arg1)->AMax = arg2;
7738+ return Qnil;
7739+fail:
7740+ return Qnil;
7741+}
7742+
7743+
7744+SWIGINTERN VALUE
7745+_wrap__mrcImageHeaderIMOD_AMax_get(int argc, VALUE *argv, VALUE self) {
7746+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7747+ void *argp1 = 0 ;
7748+ int res1 = 0 ;
7749+ mrcImageParaTypeReal result;
7750+ VALUE vresult = Qnil;
7751+
7752+ if ((argc < 0) || (argc > 0)) {
7753+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7754+ }
7755+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7756+ if (!SWIG_IsOK(res1)) {
7757+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","AMax", 1, self ));
7758+ }
7759+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7760+ result = (mrcImageParaTypeReal) ((arg1)->AMax);
7761+ vresult = SWIG_From_float((float)(result));
7762+ return vresult;
7763+fail:
7764+ return Qnil;
7765+}
7766+
7767+
7768+SWIGINTERN VALUE
7769+_wrap__mrcImageHeaderIMOD_AMean_set(int argc, VALUE *argv, VALUE self) {
7770+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7771+ mrcImageParaTypeReal arg2 ;
7772+ void *argp1 = 0 ;
7773+ int res1 = 0 ;
7774+ float val2 ;
7775+ int ecode2 = 0 ;
7776+
7777+ if ((argc < 1) || (argc > 1)) {
7778+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7779+ }
7780+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7781+ if (!SWIG_IsOK(res1)) {
7782+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","AMean", 1, self ));
7783+ }
7784+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7785+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
7786+ if (!SWIG_IsOK(ecode2)) {
7787+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","AMean", 2, argv[0] ));
7788+ }
7789+ arg2 = (mrcImageParaTypeReal)(val2);
7790+ if (arg1) (arg1)->AMean = arg2;
7791+ return Qnil;
7792+fail:
7793+ return Qnil;
7794+}
7795+
7796+
7797+SWIGINTERN VALUE
7798+_wrap__mrcImageHeaderIMOD_AMean_get(int argc, VALUE *argv, VALUE self) {
7799+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7800+ void *argp1 = 0 ;
7801+ int res1 = 0 ;
7802+ mrcImageParaTypeReal result;
7803+ VALUE vresult = Qnil;
7804+
7805+ if ((argc < 0) || (argc > 0)) {
7806+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7807+ }
7808+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7809+ if (!SWIG_IsOK(res1)) {
7810+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","AMean", 1, self ));
7811+ }
7812+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7813+ result = (mrcImageParaTypeReal) ((arg1)->AMean);
7814+ vresult = SWIG_From_float((float)(result));
7815+ return vresult;
7816+fail:
7817+ return Qnil;
7818+}
7819+
7820+
7821+SWIGINTERN VALUE
7822+_wrap__mrcImageHeaderIMOD_ISPG_set(int argc, VALUE *argv, VALUE self) {
7823+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7824+ mrcImageParaTypeInteger arg2 ;
7825+ void *argp1 = 0 ;
7826+ int res1 = 0 ;
7827+ int val2 ;
7828+ int ecode2 = 0 ;
7829+
7830+ if ((argc < 1) || (argc > 1)) {
7831+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7832+ }
7833+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7834+ if (!SWIG_IsOK(res1)) {
7835+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","ISPG", 1, self ));
7836+ }
7837+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7838+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
7839+ if (!SWIG_IsOK(ecode2)) {
7840+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","ISPG", 2, argv[0] ));
7841+ }
7842+ arg2 = (mrcImageParaTypeInteger)(val2);
7843+ if (arg1) (arg1)->ISPG = arg2;
7844+ return Qnil;
7845+fail:
7846+ return Qnil;
7847+}
7848+
7849+
7850+SWIGINTERN VALUE
7851+_wrap__mrcImageHeaderIMOD_ISPG_get(int argc, VALUE *argv, VALUE self) {
7852+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7853+ void *argp1 = 0 ;
7854+ int res1 = 0 ;
7855+ mrcImageParaTypeInteger result;
7856+ VALUE vresult = Qnil;
7857+
7858+ if ((argc < 0) || (argc > 0)) {
7859+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7860+ }
7861+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7862+ if (!SWIG_IsOK(res1)) {
7863+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","ISPG", 1, self ));
7864+ }
7865+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7866+ result = (mrcImageParaTypeInteger) ((arg1)->ISPG);
7867+ vresult = SWIG_From_int((int)(result));
7868+ return vresult;
7869+fail:
7870+ return Qnil;
7871+}
7872+
7873+
7874+SWIGINTERN VALUE
7875+_wrap__mrcImageHeaderIMOD_NSYMBT_set(int argc, VALUE *argv, VALUE self) {
7876+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7877+ mrcImageParaTypeInteger arg2 ;
7878+ void *argp1 = 0 ;
7879+ int res1 = 0 ;
7880+ int val2 ;
7881+ int ecode2 = 0 ;
7882+
7883+ if ((argc < 1) || (argc > 1)) {
7884+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7885+ }
7886+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7887+ if (!SWIG_IsOK(res1)) {
7888+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","NSYMBT", 1, self ));
7889+ }
7890+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7891+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
7892+ if (!SWIG_IsOK(ecode2)) {
7893+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","NSYMBT", 2, argv[0] ));
7894+ }
7895+ arg2 = (mrcImageParaTypeInteger)(val2);
7896+ if (arg1) (arg1)->NSYMBT = arg2;
7897+ return Qnil;
7898+fail:
7899+ return Qnil;
7900+}
7901+
7902+
7903+SWIGINTERN VALUE
7904+_wrap__mrcImageHeaderIMOD_NSYMBT_get(int argc, VALUE *argv, VALUE self) {
7905+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7906+ void *argp1 = 0 ;
7907+ int res1 = 0 ;
7908+ mrcImageParaTypeInteger result;
7909+ VALUE vresult = Qnil;
7910+
7911+ if ((argc < 0) || (argc > 0)) {
7912+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7913+ }
7914+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7915+ if (!SWIG_IsOK(res1)) {
7916+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","NSYMBT", 1, self ));
7917+ }
7918+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7919+ result = (mrcImageParaTypeInteger) ((arg1)->NSYMBT);
7920+ vresult = SWIG_From_int((int)(result));
7921+ return vresult;
7922+fail:
7923+ return Qnil;
7924+}
7925+
7926+
7927+SWIGINTERN VALUE
7928+_wrap__mrcImageHeaderIMOD_creatid_set(int argc, VALUE *argv, VALUE self) {
7929+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7930+ short arg2 ;
7931+ void *argp1 = 0 ;
7932+ int res1 = 0 ;
7933+ short val2 ;
7934+ int ecode2 = 0 ;
7935+
7936+ if ((argc < 1) || (argc > 1)) {
7937+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7938+ }
7939+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7940+ if (!SWIG_IsOK(res1)) {
7941+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","creatid", 1, self ));
7942+ }
7943+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7944+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
7945+ if (!SWIG_IsOK(ecode2)) {
7946+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","creatid", 2, argv[0] ));
7947+ }
7948+ arg2 = (short)(val2);
7949+ if (arg1) (arg1)->creatid = arg2;
7950+ return Qnil;
7951+fail:
7952+ return Qnil;
7953+}
7954+
7955+
7956+SWIGINTERN VALUE
7957+_wrap__mrcImageHeaderIMOD_creatid_get(int argc, VALUE *argv, VALUE self) {
7958+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7959+ void *argp1 = 0 ;
7960+ int res1 = 0 ;
7961+ short result;
7962+ VALUE vresult = Qnil;
7963+
7964+ if ((argc < 0) || (argc > 0)) {
7965+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
7966+ }
7967+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7968+ if (!SWIG_IsOK(res1)) {
7969+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","creatid", 1, self ));
7970+ }
7971+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7972+ result = (short) ((arg1)->creatid);
7973+ vresult = SWIG_From_short((short)(result));
7974+ return vresult;
7975+fail:
7976+ return Qnil;
7977+}
7978+
7979+
7980+SWIGINTERN VALUE
7981+_wrap__mrcImageHeaderIMOD_extra1_set(int argc, VALUE *argv, VALUE self) {
7982+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
7983+ short *arg2 ;
7984+ void *argp1 = 0 ;
7985+ int res1 = 0 ;
7986+ void *argp2 = 0 ;
7987+ int res2 = 0 ;
7988+
7989+ if ((argc < 1) || (argc > 1)) {
7990+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
7991+ }
7992+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
7993+ if (!SWIG_IsOK(res1)) {
7994+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","extra1", 1, self ));
7995+ }
7996+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
7997+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_short, 0 | 0 );
7998+ if (!SWIG_IsOK(res2)) {
7999+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "short [15]","extra1", 2, argv[0] ));
8000+ }
8001+ arg2 = (short *)(argp2);
8002+ {
8003+ if (arg2) {
8004+ size_t ii = 0;
8005+ for (; ii < (size_t)15; ++ii) arg1->extra1[ii] = arg2[ii];
8006+ } else {
8007+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""extra1""' of type '""short [15]""'");
8008+ }
8009+ }
8010+ return Qnil;
8011+fail:
8012+ return Qnil;
8013+}
8014+
8015+
8016+SWIGINTERN VALUE
8017+_wrap__mrcImageHeaderIMOD_extra1_get(int argc, VALUE *argv, VALUE self) {
8018+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8019+ void *argp1 = 0 ;
8020+ int res1 = 0 ;
8021+ short *result = 0 ;
8022+ VALUE vresult = Qnil;
8023+
8024+ if ((argc < 0) || (argc > 0)) {
8025+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8026+ }
8027+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8028+ if (!SWIG_IsOK(res1)) {
8029+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","extra1", 1, self ));
8030+ }
8031+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8032+ result = (short *)(short *) ((arg1)->extra1);
8033+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 );
8034+ return vresult;
8035+fail:
8036+ return Qnil;
8037+}
8038+
8039+
8040+SWIGINTERN VALUE
8041+_wrap__mrcImageHeaderIMOD_nint_set(int argc, VALUE *argv, VALUE self) {
8042+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8043+ short arg2 ;
8044+ void *argp1 = 0 ;
8045+ int res1 = 0 ;
8046+ short val2 ;
8047+ int ecode2 = 0 ;
8048+
8049+ if ((argc < 1) || (argc > 1)) {
8050+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8051+ }
8052+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8053+ if (!SWIG_IsOK(res1)) {
8054+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","nint", 1, self ));
8055+ }
8056+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8057+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
8058+ if (!SWIG_IsOK(ecode2)) {
8059+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","nint", 2, argv[0] ));
8060+ }
8061+ arg2 = (short)(val2);
8062+ if (arg1) (arg1)->nint = arg2;
8063+ return Qnil;
8064+fail:
8065+ return Qnil;
8066+}
8067+
8068+
8069+SWIGINTERN VALUE
8070+_wrap__mrcImageHeaderIMOD_nint_get(int argc, VALUE *argv, VALUE self) {
8071+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8072+ void *argp1 = 0 ;
8073+ int res1 = 0 ;
8074+ short result;
8075+ VALUE vresult = Qnil;
8076+
8077+ if ((argc < 0) || (argc > 0)) {
8078+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8079+ }
8080+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8081+ if (!SWIG_IsOK(res1)) {
8082+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","nint", 1, self ));
8083+ }
8084+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8085+ result = (short) ((arg1)->nint);
8086+ vresult = SWIG_From_short((short)(result));
8087+ return vresult;
8088+fail:
8089+ return Qnil;
8090+}
8091+
8092+
8093+SWIGINTERN VALUE
8094+_wrap__mrcImageHeaderIMOD_nreal_set(int argc, VALUE *argv, VALUE self) {
8095+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8096+ short arg2 ;
8097+ void *argp1 = 0 ;
8098+ int res1 = 0 ;
8099+ short val2 ;
8100+ int ecode2 = 0 ;
8101+
8102+ if ((argc < 1) || (argc > 1)) {
8103+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8104+ }
8105+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8106+ if (!SWIG_IsOK(res1)) {
8107+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","nreal", 1, self ));
8108+ }
8109+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8110+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
8111+ if (!SWIG_IsOK(ecode2)) {
8112+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","nreal", 2, argv[0] ));
8113+ }
8114+ arg2 = (short)(val2);
8115+ if (arg1) (arg1)->nreal = arg2;
8116+ return Qnil;
8117+fail:
8118+ return Qnil;
8119+}
8120+
8121+
8122+SWIGINTERN VALUE
8123+_wrap__mrcImageHeaderIMOD_nreal_get(int argc, VALUE *argv, VALUE self) {
8124+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8125+ void *argp1 = 0 ;
8126+ int res1 = 0 ;
8127+ short result;
8128+ VALUE vresult = Qnil;
8129+
8130+ if ((argc < 0) || (argc > 0)) {
8131+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8132+ }
8133+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8134+ if (!SWIG_IsOK(res1)) {
8135+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","nreal", 1, self ));
8136+ }
8137+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8138+ result = (short) ((arg1)->nreal);
8139+ vresult = SWIG_From_short((short)(result));
8140+ return vresult;
8141+fail:
8142+ return Qnil;
8143+}
8144+
8145+
8146+SWIGINTERN VALUE
8147+_wrap__mrcImageHeaderIMOD_extra2_set(int argc, VALUE *argv, VALUE self) {
8148+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8149+ mrcImageParaTypeReal *arg2 ;
8150+ void *argp1 = 0 ;
8151+ int res1 = 0 ;
8152+ void *argp2 = 0 ;
8153+ int res2 = 0 ;
8154+
8155+ if ((argc < 1) || (argc > 1)) {
8156+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8157+ }
8158+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8159+ if (!SWIG_IsOK(res1)) {
8160+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","extra2", 1, self ));
8161+ }
8162+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8163+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
8164+ if (!SWIG_IsOK(res2)) {
8165+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [5]","extra2", 2, argv[0] ));
8166+ }
8167+ arg2 = (mrcImageParaTypeReal *)(argp2);
8168+ {
8169+ if (arg2) {
8170+ size_t ii = 0;
8171+ for (; ii < (size_t)5; ++ii) arg1->extra2[ii] = arg2[ii];
8172+ } else {
8173+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""extra2""' of type '""mrcImageParaTypeReal [5]""'");
8174+ }
8175+ }
8176+ return Qnil;
8177+fail:
8178+ return Qnil;
8179+}
8180+
8181+
8182+SWIGINTERN VALUE
8183+_wrap__mrcImageHeaderIMOD_extra2_get(int argc, VALUE *argv, VALUE self) {
8184+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8185+ void *argp1 = 0 ;
8186+ int res1 = 0 ;
8187+ mrcImageParaTypeReal *result = 0 ;
8188+ VALUE vresult = Qnil;
8189+
8190+ if ((argc < 0) || (argc > 0)) {
8191+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8192+ }
8193+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8194+ if (!SWIG_IsOK(res1)) {
8195+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","extra2", 1, self ));
8196+ }
8197+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8198+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->extra2);
8199+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
8200+ return vresult;
8201+fail:
8202+ return Qnil;
8203+}
8204+
8205+
8206+SWIGINTERN VALUE
8207+_wrap__mrcImageHeaderIMOD_imodStamp_set(int argc, VALUE *argv, VALUE self) {
8208+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8209+ mrcImageParaTypeInteger arg2 ;
8210+ void *argp1 = 0 ;
8211+ int res1 = 0 ;
8212+ int val2 ;
8213+ int ecode2 = 0 ;
8214+
8215+ if ((argc < 1) || (argc > 1)) {
8216+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8217+ }
8218+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8219+ if (!SWIG_IsOK(res1)) {
8220+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","imodStamp", 1, self ));
8221+ }
8222+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8223+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
8224+ if (!SWIG_IsOK(ecode2)) {
8225+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","imodStamp", 2, argv[0] ));
8226+ }
8227+ arg2 = (mrcImageParaTypeInteger)(val2);
8228+ if (arg1) (arg1)->imodStamp = arg2;
8229+ return Qnil;
8230+fail:
8231+ return Qnil;
8232+}
8233+
8234+
8235+SWIGINTERN VALUE
8236+_wrap__mrcImageHeaderIMOD_imodStamp_get(int argc, VALUE *argv, VALUE self) {
8237+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8238+ void *argp1 = 0 ;
8239+ int res1 = 0 ;
8240+ mrcImageParaTypeInteger result;
8241+ VALUE vresult = Qnil;
8242+
8243+ if ((argc < 0) || (argc > 0)) {
8244+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8245+ }
8246+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8247+ if (!SWIG_IsOK(res1)) {
8248+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","imodStamp", 1, self ));
8249+ }
8250+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8251+ result = (mrcImageParaTypeInteger) ((arg1)->imodStamp);
8252+ vresult = SWIG_From_int((int)(result));
8253+ return vresult;
8254+fail:
8255+ return Qnil;
8256+}
8257+
8258+
8259+SWIGINTERN VALUE
8260+_wrap__mrcImageHeaderIMOD_imodFlags_set(int argc, VALUE *argv, VALUE self) {
8261+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8262+ mrcImageParaTypeInteger arg2 ;
8263+ void *argp1 = 0 ;
8264+ int res1 = 0 ;
8265+ int val2 ;
8266+ int ecode2 = 0 ;
8267+
8268+ if ((argc < 1) || (argc > 1)) {
8269+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8270+ }
8271+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8272+ if (!SWIG_IsOK(res1)) {
8273+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","imodFlags", 1, self ));
8274+ }
8275+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8276+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
8277+ if (!SWIG_IsOK(ecode2)) {
8278+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","imodFlags", 2, argv[0] ));
8279+ }
8280+ arg2 = (mrcImageParaTypeInteger)(val2);
8281+ if (arg1) (arg1)->imodFlags = arg2;
8282+ return Qnil;
8283+fail:
8284+ return Qnil;
8285+}
8286+
8287+
8288+SWIGINTERN VALUE
8289+_wrap__mrcImageHeaderIMOD_imodFlags_get(int argc, VALUE *argv, VALUE self) {
8290+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8291+ void *argp1 = 0 ;
8292+ int res1 = 0 ;
8293+ mrcImageParaTypeInteger result;
8294+ VALUE vresult = Qnil;
8295+
8296+ if ((argc < 0) || (argc > 0)) {
8297+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8298+ }
8299+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8300+ if (!SWIG_IsOK(res1)) {
8301+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","imodFlags", 1, self ));
8302+ }
8303+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8304+ result = (mrcImageParaTypeInteger) ((arg1)->imodFlags);
8305+ vresult = SWIG_From_int((int)(result));
8306+ return vresult;
8307+fail:
8308+ return Qnil;
8309+}
8310+
8311+
8312+SWIGINTERN VALUE
8313+_wrap__mrcImageHeaderIMOD_idtype_set(int argc, VALUE *argv, VALUE self) {
8314+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8315+ short arg2 ;
8316+ void *argp1 = 0 ;
8317+ int res1 = 0 ;
8318+ short val2 ;
8319+ int ecode2 = 0 ;
8320+
8321+ if ((argc < 1) || (argc > 1)) {
8322+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8323+ }
8324+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8325+ if (!SWIG_IsOK(res1)) {
8326+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","idtype", 1, self ));
8327+ }
8328+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8329+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
8330+ if (!SWIG_IsOK(ecode2)) {
8331+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","idtype", 2, argv[0] ));
8332+ }
8333+ arg2 = (short)(val2);
8334+ if (arg1) (arg1)->idtype = arg2;
8335+ return Qnil;
8336+fail:
8337+ return Qnil;
8338+}
8339+
8340+
8341+SWIGINTERN VALUE
8342+_wrap__mrcImageHeaderIMOD_idtype_get(int argc, VALUE *argv, VALUE self) {
8343+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8344+ void *argp1 = 0 ;
8345+ int res1 = 0 ;
8346+ short result;
8347+ VALUE vresult = Qnil;
8348+
8349+ if ((argc < 0) || (argc > 0)) {
8350+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8351+ }
8352+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8353+ if (!SWIG_IsOK(res1)) {
8354+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","idtype", 1, self ));
8355+ }
8356+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8357+ result = (short) ((arg1)->idtype);
8358+ vresult = SWIG_From_short((short)(result));
8359+ return vresult;
8360+fail:
8361+ return Qnil;
8362+}
8363+
8364+
8365+SWIGINTERN VALUE
8366+_wrap__mrcImageHeaderIMOD_lnes_set(int argc, VALUE *argv, VALUE self) {
8367+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8368+ short arg2 ;
8369+ void *argp1 = 0 ;
8370+ int res1 = 0 ;
8371+ short val2 ;
8372+ int ecode2 = 0 ;
8373+
8374+ if ((argc < 1) || (argc > 1)) {
8375+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8376+ }
8377+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8378+ if (!SWIG_IsOK(res1)) {
8379+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","lnes", 1, self ));
8380+ }
8381+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8382+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
8383+ if (!SWIG_IsOK(ecode2)) {
8384+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","lnes", 2, argv[0] ));
8385+ }
8386+ arg2 = (short)(val2);
8387+ if (arg1) (arg1)->lnes = arg2;
8388+ return Qnil;
8389+fail:
8390+ return Qnil;
8391+}
8392+
8393+
8394+SWIGINTERN VALUE
8395+_wrap__mrcImageHeaderIMOD_lnes_get(int argc, VALUE *argv, VALUE self) {
8396+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8397+ void *argp1 = 0 ;
8398+ int res1 = 0 ;
8399+ short result;
8400+ VALUE vresult = Qnil;
8401+
8402+ if ((argc < 0) || (argc > 0)) {
8403+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8404+ }
8405+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8406+ if (!SWIG_IsOK(res1)) {
8407+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","lnes", 1, self ));
8408+ }
8409+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8410+ result = (short) ((arg1)->lnes);
8411+ vresult = SWIG_From_short((short)(result));
8412+ return vresult;
8413+fail:
8414+ return Qnil;
8415+}
8416+
8417+
8418+SWIGINTERN VALUE
8419+_wrap__mrcImageHeaderIMOD_nd1_set(int argc, VALUE *argv, VALUE self) {
8420+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8421+ short arg2 ;
8422+ void *argp1 = 0 ;
8423+ int res1 = 0 ;
8424+ short val2 ;
8425+ int ecode2 = 0 ;
8426+
8427+ if ((argc < 1) || (argc > 1)) {
8428+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8429+ }
8430+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8431+ if (!SWIG_IsOK(res1)) {
8432+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","nd1", 1, self ));
8433+ }
8434+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8435+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
8436+ if (!SWIG_IsOK(ecode2)) {
8437+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","nd1", 2, argv[0] ));
8438+ }
8439+ arg2 = (short)(val2);
8440+ if (arg1) (arg1)->nd1 = arg2;
8441+ return Qnil;
8442+fail:
8443+ return Qnil;
8444+}
8445+
8446+
8447+SWIGINTERN VALUE
8448+_wrap__mrcImageHeaderIMOD_nd1_get(int argc, VALUE *argv, VALUE self) {
8449+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8450+ void *argp1 = 0 ;
8451+ int res1 = 0 ;
8452+ short result;
8453+ VALUE vresult = Qnil;
8454+
8455+ if ((argc < 0) || (argc > 0)) {
8456+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8457+ }
8458+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8459+ if (!SWIG_IsOK(res1)) {
8460+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","nd1", 1, self ));
8461+ }
8462+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8463+ result = (short) ((arg1)->nd1);
8464+ vresult = SWIG_From_short((short)(result));
8465+ return vresult;
8466+fail:
8467+ return Qnil;
8468+}
8469+
8470+
8471+SWIGINTERN VALUE
8472+_wrap__mrcImageHeaderIMOD_nd2_set(int argc, VALUE *argv, VALUE self) {
8473+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8474+ short arg2 ;
8475+ void *argp1 = 0 ;
8476+ int res1 = 0 ;
8477+ short val2 ;
8478+ int ecode2 = 0 ;
8479+
8480+ if ((argc < 1) || (argc > 1)) {
8481+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8482+ }
8483+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8484+ if (!SWIG_IsOK(res1)) {
8485+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","nd2", 1, self ));
8486+ }
8487+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8488+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
8489+ if (!SWIG_IsOK(ecode2)) {
8490+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","nd2", 2, argv[0] ));
8491+ }
8492+ arg2 = (short)(val2);
8493+ if (arg1) (arg1)->nd2 = arg2;
8494+ return Qnil;
8495+fail:
8496+ return Qnil;
8497+}
8498+
8499+
8500+SWIGINTERN VALUE
8501+_wrap__mrcImageHeaderIMOD_nd2_get(int argc, VALUE *argv, VALUE self) {
8502+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8503+ void *argp1 = 0 ;
8504+ int res1 = 0 ;
8505+ short result;
8506+ VALUE vresult = Qnil;
8507+
8508+ if ((argc < 0) || (argc > 0)) {
8509+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8510+ }
8511+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8512+ if (!SWIG_IsOK(res1)) {
8513+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","nd2", 1, self ));
8514+ }
8515+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8516+ result = (short) ((arg1)->nd2);
8517+ vresult = SWIG_From_short((short)(result));
8518+ return vresult;
8519+fail:
8520+ return Qnil;
8521+}
8522+
8523+
8524+SWIGINTERN VALUE
8525+_wrap__mrcImageHeaderIMOD_vd1_set(int argc, VALUE *argv, VALUE self) {
8526+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8527+ short arg2 ;
8528+ void *argp1 = 0 ;
8529+ int res1 = 0 ;
8530+ short val2 ;
8531+ int ecode2 = 0 ;
8532+
8533+ if ((argc < 1) || (argc > 1)) {
8534+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8535+ }
8536+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8537+ if (!SWIG_IsOK(res1)) {
8538+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","vd1", 1, self ));
8539+ }
8540+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8541+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
8542+ if (!SWIG_IsOK(ecode2)) {
8543+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","vd1", 2, argv[0] ));
8544+ }
8545+ arg2 = (short)(val2);
8546+ if (arg1) (arg1)->vd1 = arg2;
8547+ return Qnil;
8548+fail:
8549+ return Qnil;
8550+}
8551+
8552+
8553+SWIGINTERN VALUE
8554+_wrap__mrcImageHeaderIMOD_vd1_get(int argc, VALUE *argv, VALUE self) {
8555+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8556+ void *argp1 = 0 ;
8557+ int res1 = 0 ;
8558+ short result;
8559+ VALUE vresult = Qnil;
8560+
8561+ if ((argc < 0) || (argc > 0)) {
8562+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8563+ }
8564+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8565+ if (!SWIG_IsOK(res1)) {
8566+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","vd1", 1, self ));
8567+ }
8568+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8569+ result = (short) ((arg1)->vd1);
8570+ vresult = SWIG_From_short((short)(result));
8571+ return vresult;
8572+fail:
8573+ return Qnil;
8574+}
8575+
8576+
8577+SWIGINTERN VALUE
8578+_wrap__mrcImageHeaderIMOD_vd2_set(int argc, VALUE *argv, VALUE self) {
8579+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8580+ short arg2 ;
8581+ void *argp1 = 0 ;
8582+ int res1 = 0 ;
8583+ short val2 ;
8584+ int ecode2 = 0 ;
8585+
8586+ if ((argc < 1) || (argc > 1)) {
8587+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8588+ }
8589+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8590+ if (!SWIG_IsOK(res1)) {
8591+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","vd2", 1, self ));
8592+ }
8593+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8594+ ecode2 = SWIG_AsVal_short(argv[0], &val2);
8595+ if (!SWIG_IsOK(ecode2)) {
8596+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "short","vd2", 2, argv[0] ));
8597+ }
8598+ arg2 = (short)(val2);
8599+ if (arg1) (arg1)->vd2 = arg2;
8600+ return Qnil;
8601+fail:
8602+ return Qnil;
8603+}
8604+
8605+
8606+SWIGINTERN VALUE
8607+_wrap__mrcImageHeaderIMOD_vd2_get(int argc, VALUE *argv, VALUE self) {
8608+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8609+ void *argp1 = 0 ;
8610+ int res1 = 0 ;
8611+ short result;
8612+ VALUE vresult = Qnil;
8613+
8614+ if ((argc < 0) || (argc > 0)) {
8615+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8616+ }
8617+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8618+ if (!SWIG_IsOK(res1)) {
8619+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","vd2", 1, self ));
8620+ }
8621+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8622+ result = (short) ((arg1)->vd2);
8623+ vresult = SWIG_From_short((short)(result));
8624+ return vresult;
8625+fail:
8626+ return Qnil;
8627+}
8628+
8629+
8630+SWIGINTERN VALUE
8631+_wrap__mrcImageHeaderIMOD_tiltangles_set(int argc, VALUE *argv, VALUE self) {
8632+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8633+ mrcImageParaTypeReal *arg2 ;
8634+ void *argp1 = 0 ;
8635+ int res1 = 0 ;
8636+ void *argp2 = 0 ;
8637+ int res2 = 0 ;
8638+
8639+ if ((argc < 1) || (argc > 1)) {
8640+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8641+ }
8642+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8643+ if (!SWIG_IsOK(res1)) {
8644+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","tiltangles", 1, self ));
8645+ }
8646+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8647+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
8648+ if (!SWIG_IsOK(res2)) {
8649+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [6]","tiltangles", 2, argv[0] ));
8650+ }
8651+ arg2 = (mrcImageParaTypeReal *)(argp2);
8652+ {
8653+ if (arg2) {
8654+ size_t ii = 0;
8655+ for (; ii < (size_t)6; ++ii) arg1->tiltangles[ii] = arg2[ii];
8656+ } else {
8657+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""tiltangles""' of type '""mrcImageParaTypeReal [6]""'");
8658+ }
8659+ }
8660+ return Qnil;
8661+fail:
8662+ return Qnil;
8663+}
8664+
8665+
8666+SWIGINTERN VALUE
8667+_wrap__mrcImageHeaderIMOD_tiltangles_get(int argc, VALUE *argv, VALUE self) {
8668+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8669+ void *argp1 = 0 ;
8670+ int res1 = 0 ;
8671+ mrcImageParaTypeReal *result = 0 ;
8672+ VALUE vresult = Qnil;
8673+
8674+ if ((argc < 0) || (argc > 0)) {
8675+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8676+ }
8677+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8678+ if (!SWIG_IsOK(res1)) {
8679+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","tiltangles", 1, self ));
8680+ }
8681+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8682+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->tiltangles);
8683+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
8684+ return vresult;
8685+fail:
8686+ return Qnil;
8687+}
8688+
8689+
8690+SWIGINTERN VALUE
8691+_wrap__mrcImageHeaderIMOD_xorg_set(int argc, VALUE *argv, VALUE self) {
8692+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8693+ mrcImageParaTypeReal arg2 ;
8694+ void *argp1 = 0 ;
8695+ int res1 = 0 ;
8696+ float val2 ;
8697+ int ecode2 = 0 ;
8698+
8699+ if ((argc < 1) || (argc > 1)) {
8700+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8701+ }
8702+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8703+ if (!SWIG_IsOK(res1)) {
8704+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","xorg", 1, self ));
8705+ }
8706+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8707+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
8708+ if (!SWIG_IsOK(ecode2)) {
8709+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","xorg", 2, argv[0] ));
8710+ }
8711+ arg2 = (mrcImageParaTypeReal)(val2);
8712+ if (arg1) (arg1)->xorg = arg2;
8713+ return Qnil;
8714+fail:
8715+ return Qnil;
8716+}
8717+
8718+
8719+SWIGINTERN VALUE
8720+_wrap__mrcImageHeaderIMOD_xorg_get(int argc, VALUE *argv, VALUE self) {
8721+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8722+ void *argp1 = 0 ;
8723+ int res1 = 0 ;
8724+ mrcImageParaTypeReal result;
8725+ VALUE vresult = Qnil;
8726+
8727+ if ((argc < 0) || (argc > 0)) {
8728+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8729+ }
8730+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8731+ if (!SWIG_IsOK(res1)) {
8732+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","xorg", 1, self ));
8733+ }
8734+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8735+ result = (mrcImageParaTypeReal) ((arg1)->xorg);
8736+ vresult = SWIG_From_float((float)(result));
8737+ return vresult;
8738+fail:
8739+ return Qnil;
8740+}
8741+
8742+
8743+SWIGINTERN VALUE
8744+_wrap__mrcImageHeaderIMOD_yorg_set(int argc, VALUE *argv, VALUE self) {
8745+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8746+ mrcImageParaTypeReal arg2 ;
8747+ void *argp1 = 0 ;
8748+ int res1 = 0 ;
8749+ float val2 ;
8750+ int ecode2 = 0 ;
8751+
8752+ if ((argc < 1) || (argc > 1)) {
8753+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8754+ }
8755+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8756+ if (!SWIG_IsOK(res1)) {
8757+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","yorg", 1, self ));
8758+ }
8759+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8760+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
8761+ if (!SWIG_IsOK(ecode2)) {
8762+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","yorg", 2, argv[0] ));
8763+ }
8764+ arg2 = (mrcImageParaTypeReal)(val2);
8765+ if (arg1) (arg1)->yorg = arg2;
8766+ return Qnil;
8767+fail:
8768+ return Qnil;
8769+}
8770+
8771+
8772+SWIGINTERN VALUE
8773+_wrap__mrcImageHeaderIMOD_yorg_get(int argc, VALUE *argv, VALUE self) {
8774+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8775+ void *argp1 = 0 ;
8776+ int res1 = 0 ;
8777+ mrcImageParaTypeReal result;
8778+ VALUE vresult = Qnil;
8779+
8780+ if ((argc < 0) || (argc > 0)) {
8781+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8782+ }
8783+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8784+ if (!SWIG_IsOK(res1)) {
8785+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","yorg", 1, self ));
8786+ }
8787+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8788+ result = (mrcImageParaTypeReal) ((arg1)->yorg);
8789+ vresult = SWIG_From_float((float)(result));
8790+ return vresult;
8791+fail:
8792+ return Qnil;
8793+}
8794+
8795+
8796+SWIGINTERN VALUE
8797+_wrap__mrcImageHeaderIMOD_zorg_set(int argc, VALUE *argv, VALUE self) {
8798+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8799+ mrcImageParaTypeReal arg2 ;
8800+ void *argp1 = 0 ;
8801+ int res1 = 0 ;
8802+ float val2 ;
8803+ int ecode2 = 0 ;
8804+
8805+ if ((argc < 1) || (argc > 1)) {
8806+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8807+ }
8808+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8809+ if (!SWIG_IsOK(res1)) {
8810+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","zorg", 1, self ));
8811+ }
8812+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8813+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
8814+ if (!SWIG_IsOK(ecode2)) {
8815+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","zorg", 2, argv[0] ));
8816+ }
8817+ arg2 = (mrcImageParaTypeReal)(val2);
8818+ if (arg1) (arg1)->zorg = arg2;
8819+ return Qnil;
8820+fail:
8821+ return Qnil;
8822+}
8823+
8824+
8825+SWIGINTERN VALUE
8826+_wrap__mrcImageHeaderIMOD_zorg_get(int argc, VALUE *argv, VALUE self) {
8827+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8828+ void *argp1 = 0 ;
8829+ int res1 = 0 ;
8830+ mrcImageParaTypeReal result;
8831+ VALUE vresult = Qnil;
8832+
8833+ if ((argc < 0) || (argc > 0)) {
8834+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8835+ }
8836+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8837+ if (!SWIG_IsOK(res1)) {
8838+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","zorg", 1, self ));
8839+ }
8840+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8841+ result = (mrcImageParaTypeReal) ((arg1)->zorg);
8842+ vresult = SWIG_From_float((float)(result));
8843+ return vresult;
8844+fail:
8845+ return Qnil;
8846+}
8847+
8848+
8849+SWIGINTERN VALUE
8850+_wrap__mrcImageHeaderIMOD_MAP_set(int argc, VALUE *argv, VALUE self) {
8851+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8852+ mrcImageParaTypeCharacter *arg2 ;
8853+ void *argp1 = 0 ;
8854+ int res1 = 0 ;
8855+ void *argp2 = 0 ;
8856+ int res2 = 0 ;
8857+
8858+ if ((argc < 1) || (argc > 1)) {
8859+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8860+ }
8861+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8862+ if (!SWIG_IsOK(res1)) {
8863+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MAP", 1, self ));
8864+ }
8865+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8866+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
8867+ if (!SWIG_IsOK(res2)) {
8868+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeCharacter [4]","MAP", 2, argv[0] ));
8869+ }
8870+ arg2 = (mrcImageParaTypeCharacter *)(argp2);
8871+ {
8872+ if (arg2) {
8873+ size_t ii = 0;
8874+ for (; ii < (size_t)4; ++ii) arg1->MAP[ii] = arg2[ii];
8875+ } else {
8876+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""MAP""' of type '""mrcImageParaTypeCharacter [4]""'");
8877+ }
8878+ }
8879+ return Qnil;
8880+fail:
8881+ return Qnil;
8882+}
8883+
8884+
8885+SWIGINTERN VALUE
8886+_wrap__mrcImageHeaderIMOD_MAP_get(int argc, VALUE *argv, VALUE self) {
8887+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8888+ void *argp1 = 0 ;
8889+ int res1 = 0 ;
8890+ mrcImageParaTypeCharacter *result = 0 ;
8891+ VALUE vresult = Qnil;
8892+
8893+ if ((argc < 0) || (argc > 0)) {
8894+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8895+ }
8896+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8897+ if (!SWIG_IsOK(res1)) {
8898+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MAP", 1, self ));
8899+ }
8900+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8901+ result = (mrcImageParaTypeCharacter *)(mrcImageParaTypeCharacter *) ((arg1)->MAP);
8902+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
8903+ return vresult;
8904+fail:
8905+ return Qnil;
8906+}
8907+
8908+
8909+SWIGINTERN VALUE
8910+_wrap__mrcImageHeaderIMOD_MARCHST_set(int argc, VALUE *argv, VALUE self) {
8911+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8912+ mrcImageParaTypeInteger arg2 ;
8913+ void *argp1 = 0 ;
8914+ int res1 = 0 ;
8915+ int val2 ;
8916+ int ecode2 = 0 ;
8917+
8918+ if ((argc < 1) || (argc > 1)) {
8919+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8920+ }
8921+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8922+ if (!SWIG_IsOK(res1)) {
8923+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MARCHST", 1, self ));
8924+ }
8925+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8926+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
8927+ if (!SWIG_IsOK(ecode2)) {
8928+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","MARCHST", 2, argv[0] ));
8929+ }
8930+ arg2 = (mrcImageParaTypeInteger)(val2);
8931+ if (arg1) (arg1)->MARCHST = arg2;
8932+ return Qnil;
8933+fail:
8934+ return Qnil;
8935+}
8936+
8937+
8938+SWIGINTERN VALUE
8939+_wrap__mrcImageHeaderIMOD_MARCHST_get(int argc, VALUE *argv, VALUE self) {
8940+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8941+ void *argp1 = 0 ;
8942+ int res1 = 0 ;
8943+ mrcImageParaTypeInteger result;
8944+ VALUE vresult = Qnil;
8945+
8946+ if ((argc < 0) || (argc > 0)) {
8947+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
8948+ }
8949+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8950+ if (!SWIG_IsOK(res1)) {
8951+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","MARCHST", 1, self ));
8952+ }
8953+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8954+ result = (mrcImageParaTypeInteger) ((arg1)->MARCHST);
8955+ vresult = SWIG_From_int((int)(result));
8956+ return vresult;
8957+fail:
8958+ return Qnil;
8959+}
8960+
8961+
8962+SWIGINTERN VALUE
8963+_wrap__mrcImageHeaderIMOD_ARMS_set(int argc, VALUE *argv, VALUE self) {
8964+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8965+ mrcImageParaTypeReal arg2 ;
8966+ void *argp1 = 0 ;
8967+ int res1 = 0 ;
8968+ float val2 ;
8969+ int ecode2 = 0 ;
8970+
8971+ if ((argc < 1) || (argc > 1)) {
8972+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
8973+ }
8974+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
8975+ if (!SWIG_IsOK(res1)) {
8976+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","ARMS", 1, self ));
8977+ }
8978+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
8979+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
8980+ if (!SWIG_IsOK(ecode2)) {
8981+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","ARMS", 2, argv[0] ));
8982+ }
8983+ arg2 = (mrcImageParaTypeReal)(val2);
8984+ if (arg1) (arg1)->ARMS = arg2;
8985+ return Qnil;
8986+fail:
8987+ return Qnil;
8988+}
8989+
8990+
8991+SWIGINTERN VALUE
8992+_wrap__mrcImageHeaderIMOD_ARMS_get(int argc, VALUE *argv, VALUE self) {
8993+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
8994+ void *argp1 = 0 ;
8995+ int res1 = 0 ;
8996+ mrcImageParaTypeReal result;
8997+ VALUE vresult = Qnil;
8998+
8999+ if ((argc < 0) || (argc > 0)) {
9000+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9001+ }
9002+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
9003+ if (!SWIG_IsOK(res1)) {
9004+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","ARMS", 1, self ));
9005+ }
9006+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
9007+ result = (mrcImageParaTypeReal) ((arg1)->ARMS);
9008+ vresult = SWIG_From_float((float)(result));
9009+ return vresult;
9010+fail:
9011+ return Qnil;
9012+}
9013+
9014+
9015+SWIGINTERN VALUE
9016+_wrap__mrcImageHeaderIMOD_LabelN_set(int argc, VALUE *argv, VALUE self) {
9017+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
9018+ mrcImageParaTypeInteger arg2 ;
9019+ void *argp1 = 0 ;
9020+ int res1 = 0 ;
9021+ int val2 ;
9022+ int ecode2 = 0 ;
9023+
9024+ if ((argc < 1) || (argc > 1)) {
9025+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9026+ }
9027+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
9028+ if (!SWIG_IsOK(res1)) {
9029+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","LabelN", 1, self ));
9030+ }
9031+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
9032+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
9033+ if (!SWIG_IsOK(ecode2)) {
9034+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","LabelN", 2, argv[0] ));
9035+ }
9036+ arg2 = (mrcImageParaTypeInteger)(val2);
9037+ if (arg1) (arg1)->LabelN = arg2;
9038+ return Qnil;
9039+fail:
9040+ return Qnil;
9041+}
9042+
9043+
9044+SWIGINTERN VALUE
9045+_wrap__mrcImageHeaderIMOD_LabelN_get(int argc, VALUE *argv, VALUE self) {
9046+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
9047+ void *argp1 = 0 ;
9048+ int res1 = 0 ;
9049+ mrcImageParaTypeInteger result;
9050+ VALUE vresult = Qnil;
9051+
9052+ if ((argc < 0) || (argc > 0)) {
9053+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9054+ }
9055+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
9056+ if (!SWIG_IsOK(res1)) {
9057+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","LabelN", 1, self ));
9058+ }
9059+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
9060+ result = (mrcImageParaTypeInteger) ((arg1)->LabelN);
9061+ vresult = SWIG_From_int((int)(result));
9062+ return vresult;
9063+fail:
9064+ return Qnil;
9065+}
9066+
9067+
9068+SWIGINTERN VALUE
9069+_wrap__mrcImageHeaderIMOD_Label_set(int argc, VALUE *argv, VALUE self) {
9070+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
9071+ char (*arg2)[(80)] ;
9072+ void *argp1 = 0 ;
9073+ int res1 = 0 ;
9074+ void *argp2 = 0 ;
9075+ int res2 = 0 ;
9076+
9077+ if ((argc < 1) || (argc > 1)) {
9078+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9079+ }
9080+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
9081+ if (!SWIG_IsOK(res1)) {
9082+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Label", 1, self ));
9083+ }
9084+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
9085+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_a__80___char, 0 | 0 );
9086+ if (!SWIG_IsOK(res2)) {
9087+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [(10)][(80)]","Label", 2, argv[0] ));
9088+ }
9089+ arg2 = (char (*)[(80)])(argp2);
9090+ {
9091+ if (arg2) {
9092+ size_t ii = 0;
9093+ for (; ii < (size_t)(10); ++ii) {
9094+ if (arg2[ii]) {
9095+ size_t jj = 0;
9096+ for (; jj < (size_t)(80); ++jj) arg1->Label[ii][jj] = arg2[ii][jj];
9097+ } else {
9098+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Label""' of type '""char [(10)][(80)]""'");
9099+ }
9100+ }
9101+ } else {
9102+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Label""' of type '""char [(10)][(80)]""'");
9103+ }
9104+ }
9105+ return Qnil;
9106+fail:
9107+ return Qnil;
9108+}
9109+
9110+
9111+SWIGINTERN VALUE
9112+_wrap__mrcImageHeaderIMOD_Label_get(int argc, VALUE *argv, VALUE self) {
9113+ _mrcImageHeaderIMOD *arg1 = (_mrcImageHeaderIMOD *) 0 ;
9114+ void *argp1 = 0 ;
9115+ int res1 = 0 ;
9116+ char (*result)[(80)] = 0 ;
9117+ VALUE vresult = Qnil;
9118+
9119+ if ((argc < 0) || (argc > 0)) {
9120+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9121+ }
9122+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
9123+ if (!SWIG_IsOK(res1)) {
9124+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","Label", 1, self ));
9125+ }
9126+ arg1 = (_mrcImageHeaderIMOD *)(argp1);
9127+ result = (char (*)[(80)])(char (*)[(80)]) ((arg1)->Label);
9128+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a__80___char, 0 | 0 );
9129+ return vresult;
9130+fail:
9131+ return Qnil;
9132+}
9133+
9134+
9135+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
9136+SWIGINTERN VALUE
9137+_wrap__mrcImageHeaderIMOD_allocate(VALUE self) {
9138+#else
9139+ SWIGINTERN VALUE
9140+ _wrap__mrcImageHeaderIMOD_allocate(int argc, VALUE *argv, VALUE self) {
9141+#endif
9142+
9143+
9144+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p__mrcImageHeaderIMOD);
9145+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
9146+ rb_obj_call_init(vresult, argc, argv);
9147+#endif
9148+ return vresult;
9149+ }
9150+
9151+
9152+SWIGINTERN VALUE
9153+_wrap_new__mrcImageHeaderIMOD(int argc, VALUE *argv, VALUE self) {
9154+ _mrcImageHeaderIMOD *result = 0 ;
9155+
9156+ if ((argc < 0) || (argc > 0)) {
9157+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9158+ }
9159+ result = (_mrcImageHeaderIMOD *)calloc(1, sizeof(_mrcImageHeaderIMOD));
9160+ DATA_PTR(self) = result;
9161+ return self;
9162+fail:
9163+ return Qnil;
9164+}
9165+
9166+
9167+SWIGINTERN void
9168+free__mrcImageHeaderIMOD(_mrcImageHeaderIMOD *arg1) {
9169+ free((char *) arg1);
9170+}
9171+
9172+swig_class SwigClassMrcImageHeader;
9173+
9174+SWIGINTERN VALUE
9175+_wrap_mrcImageHeader_All_set(int argc, VALUE *argv, VALUE self) {
9176+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9177+ unsigned char *arg2 ;
9178+ void *argp1 = 0 ;
9179+ int res1 = 0 ;
9180+ void *argp2 = 0 ;
9181+ int res2 = 0 ;
9182+
9183+ if ((argc < 1) || (argc > 1)) {
9184+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9185+ }
9186+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9187+ if (!SWIG_IsOK(res1)) {
9188+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","All", 1, self ));
9189+ }
9190+ arg1 = (mrcImageHeader *)(argp1);
9191+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
9192+ if (!SWIG_IsOK(res2)) {
9193+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char [(1024)]","All", 2, argv[0] ));
9194+ }
9195+ arg2 = (unsigned char *)(argp2);
9196+ {
9197+ if (arg2) {
9198+ size_t ii = 0;
9199+ for (; ii < (size_t)(1024); ++ii) arg1->All[ii] = arg2[ii];
9200+ } else {
9201+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""All""' of type '""unsigned char [(1024)]""'");
9202+ }
9203+ }
9204+ return Qnil;
9205+fail:
9206+ return Qnil;
9207+}
9208+
9209+
9210+SWIGINTERN VALUE
9211+_wrap_mrcImageHeader_All_get(int argc, VALUE *argv, VALUE self) {
9212+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9213+ void *argp1 = 0 ;
9214+ int res1 = 0 ;
9215+ unsigned char *result = 0 ;
9216+ VALUE vresult = Qnil;
9217+
9218+ if ((argc < 0) || (argc > 0)) {
9219+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9220+ }
9221+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9222+ if (!SWIG_IsOK(res1)) {
9223+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","All", 1, self ));
9224+ }
9225+ arg1 = (mrcImageHeader *)(argp1);
9226+ result = (unsigned char *)(unsigned char *) ((arg1)->All);
9227+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
9228+ return vresult;
9229+fail:
9230+ return Qnil;
9231+}
9232+
9233+
9234+SWIGINTERN VALUE
9235+_wrap_mrcImageHeader_Int_set(int argc, VALUE *argv, VALUE self) {
9236+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9237+ mrcImageParaTypeInteger *arg2 ;
9238+ void *argp1 = 0 ;
9239+ int res1 = 0 ;
9240+ void *argp2 = 0 ;
9241+ int res2 = 0 ;
9242+
9243+ if ((argc < 1) || (argc > 1)) {
9244+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9245+ }
9246+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9247+ if (!SWIG_IsOK(res1)) {
9248+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","Int", 1, self ));
9249+ }
9250+ arg1 = (mrcImageHeader *)(argp1);
9251+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_int, 0 | 0 );
9252+ if (!SWIG_IsOK(res2)) {
9253+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger [(1024)/4]","Int", 2, argv[0] ));
9254+ }
9255+ arg2 = (mrcImageParaTypeInteger *)(argp2);
9256+ {
9257+ if (arg2) {
9258+ size_t ii = 0;
9259+ for (; ii < (size_t)(1024)/4; ++ii) arg1->Int[ii] = arg2[ii];
9260+ } else {
9261+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Int""' of type '""mrcImageParaTypeInteger [(1024)/4]""'");
9262+ }
9263+ }
9264+ return Qnil;
9265+fail:
9266+ return Qnil;
9267+}
9268+
9269+
9270+SWIGINTERN VALUE
9271+_wrap_mrcImageHeader_Int_get(int argc, VALUE *argv, VALUE self) {
9272+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9273+ void *argp1 = 0 ;
9274+ int res1 = 0 ;
9275+ mrcImageParaTypeInteger *result = 0 ;
9276+ VALUE vresult = Qnil;
9277+
9278+ if ((argc < 0) || (argc > 0)) {
9279+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9280+ }
9281+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9282+ if (!SWIG_IsOK(res1)) {
9283+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","Int", 1, self ));
9284+ }
9285+ arg1 = (mrcImageHeader *)(argp1);
9286+ result = (mrcImageParaTypeInteger *)(mrcImageParaTypeInteger *) ((arg1)->Int);
9287+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
9288+ return vresult;
9289+fail:
9290+ return Qnil;
9291+}
9292+
9293+
9294+SWIGINTERN VALUE
9295+_wrap_mrcImageHeader_Real_set(int argc, VALUE *argv, VALUE self) {
9296+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9297+ mrcImageParaTypeReal *arg2 ;
9298+ void *argp1 = 0 ;
9299+ int res1 = 0 ;
9300+ void *argp2 = 0 ;
9301+ int res2 = 0 ;
9302+
9303+ if ((argc < 1) || (argc > 1)) {
9304+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9305+ }
9306+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9307+ if (!SWIG_IsOK(res1)) {
9308+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","Real", 1, self ));
9309+ }
9310+ arg1 = (mrcImageHeader *)(argp1);
9311+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
9312+ if (!SWIG_IsOK(res2)) {
9313+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [(1024)/4]","Real", 2, argv[0] ));
9314+ }
9315+ arg2 = (mrcImageParaTypeReal *)(argp2);
9316+ {
9317+ if (arg2) {
9318+ size_t ii = 0;
9319+ for (; ii < (size_t)(1024)/4; ++ii) arg1->Real[ii] = arg2[ii];
9320+ } else {
9321+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Real""' of type '""mrcImageParaTypeReal [(1024)/4]""'");
9322+ }
9323+ }
9324+ return Qnil;
9325+fail:
9326+ return Qnil;
9327+}
9328+
9329+
9330+SWIGINTERN VALUE
9331+_wrap_mrcImageHeader_Real_get(int argc, VALUE *argv, VALUE self) {
9332+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9333+ void *argp1 = 0 ;
9334+ int res1 = 0 ;
9335+ mrcImageParaTypeReal *result = 0 ;
9336+ VALUE vresult = Qnil;
9337+
9338+ if ((argc < 0) || (argc > 0)) {
9339+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9340+ }
9341+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9342+ if (!SWIG_IsOK(res1)) {
9343+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","Real", 1, self ));
9344+ }
9345+ arg1 = (mrcImageHeader *)(argp1);
9346+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->Real);
9347+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
9348+ return vresult;
9349+fail:
9350+ return Qnil;
9351+}
9352+
9353+
9354+SWIGINTERN VALUE
9355+_wrap_mrcImageHeader_Cont_set(int argc, VALUE *argv, VALUE self) {
9356+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9357+ _mrcImageHeader *arg2 = (_mrcImageHeader *) 0 ;
9358+ void *argp1 = 0 ;
9359+ int res1 = 0 ;
9360+ void *argp2 = 0 ;
9361+ int res2 = 0 ;
9362+
9363+ if ((argc < 1) || (argc > 1)) {
9364+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9365+ }
9366+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9367+ if (!SWIG_IsOK(res1)) {
9368+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","Cont", 1, self ));
9369+ }
9370+ arg1 = (mrcImageHeader *)(argp1);
9371+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p__mrcImageHeader, 0 | 0 );
9372+ if (!SWIG_IsOK(res2)) {
9373+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_mrcImageHeader *","Cont", 2, argv[0] ));
9374+ }
9375+ arg2 = (_mrcImageHeader *)(argp2);
9376+ if (arg1) (arg1)->Cont = *arg2;
9377+ return Qnil;
9378+fail:
9379+ return Qnil;
9380+}
9381+
9382+
9383+SWIGINTERN VALUE
9384+_wrap_mrcImageHeader_Cont_get(int argc, VALUE *argv, VALUE self) {
9385+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9386+ void *argp1 = 0 ;
9387+ int res1 = 0 ;
9388+ _mrcImageHeader *result = 0 ;
9389+ VALUE vresult = Qnil;
9390+
9391+ if ((argc < 0) || (argc > 0)) {
9392+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9393+ }
9394+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9395+ if (!SWIG_IsOK(res1)) {
9396+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","Cont", 1, self ));
9397+ }
9398+ arg1 = (mrcImageHeader *)(argp1);
9399+ result = (_mrcImageHeader *)& ((arg1)->Cont);
9400+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__mrcImageHeader, 0 | 0 );
9401+ return vresult;
9402+fail:
9403+ return Qnil;
9404+}
9405+
9406+
9407+SWIGINTERN VALUE
9408+_wrap_mrcImageHeader_ContCCP4_set(int argc, VALUE *argv, VALUE self) {
9409+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9410+ _mrcImageHeaderCCP4 *arg2 = (_mrcImageHeaderCCP4 *) 0 ;
9411+ void *argp1 = 0 ;
9412+ int res1 = 0 ;
9413+ void *argp2 = 0 ;
9414+ int res2 = 0 ;
9415+
9416+ if ((argc < 1) || (argc > 1)) {
9417+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9418+ }
9419+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9420+ if (!SWIG_IsOK(res1)) {
9421+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","ContCCP4", 1, self ));
9422+ }
9423+ arg1 = (mrcImageHeader *)(argp1);
9424+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
9425+ if (!SWIG_IsOK(res2)) {
9426+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_mrcImageHeaderCCP4 *","ContCCP4", 2, argv[0] ));
9427+ }
9428+ arg2 = (_mrcImageHeaderCCP4 *)(argp2);
9429+ if (arg1) (arg1)->ContCCP4 = *arg2;
9430+ return Qnil;
9431+fail:
9432+ return Qnil;
9433+}
9434+
9435+
9436+SWIGINTERN VALUE
9437+_wrap_mrcImageHeader_ContCCP4_get(int argc, VALUE *argv, VALUE self) {
9438+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9439+ void *argp1 = 0 ;
9440+ int res1 = 0 ;
9441+ _mrcImageHeaderCCP4 *result = 0 ;
9442+ VALUE vresult = Qnil;
9443+
9444+ if ((argc < 0) || (argc > 0)) {
9445+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9446+ }
9447+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9448+ if (!SWIG_IsOK(res1)) {
9449+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","ContCCP4", 1, self ));
9450+ }
9451+ arg1 = (mrcImageHeader *)(argp1);
9452+ result = (_mrcImageHeaderCCP4 *)& ((arg1)->ContCCP4);
9453+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__mrcImageHeaderCCP4, 0 | 0 );
9454+ return vresult;
9455+fail:
9456+ return Qnil;
9457+}
9458+
9459+
9460+SWIGINTERN VALUE
9461+_wrap_mrcImageHeader_ContIMOD_set(int argc, VALUE *argv, VALUE self) {
9462+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9463+ _mrcImageHeaderIMOD *arg2 = (_mrcImageHeaderIMOD *) 0 ;
9464+ void *argp1 = 0 ;
9465+ int res1 = 0 ;
9466+ void *argp2 = 0 ;
9467+ int res2 = 0 ;
9468+
9469+ if ((argc < 1) || (argc > 1)) {
9470+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9471+ }
9472+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9473+ if (!SWIG_IsOK(res1)) {
9474+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","ContIMOD", 1, self ));
9475+ }
9476+ arg1 = (mrcImageHeader *)(argp1);
9477+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
9478+ if (!SWIG_IsOK(res2)) {
9479+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_mrcImageHeaderIMOD *","ContIMOD", 2, argv[0] ));
9480+ }
9481+ arg2 = (_mrcImageHeaderIMOD *)(argp2);
9482+ if (arg1) (arg1)->ContIMOD = *arg2;
9483+ return Qnil;
9484+fail:
9485+ return Qnil;
9486+}
9487+
9488+
9489+SWIGINTERN VALUE
9490+_wrap_mrcImageHeader_ContIMOD_get(int argc, VALUE *argv, VALUE self) {
9491+ mrcImageHeader *arg1 = (mrcImageHeader *) 0 ;
9492+ void *argp1 = 0 ;
9493+ int res1 = 0 ;
9494+ _mrcImageHeaderIMOD *result = 0 ;
9495+ VALUE vresult = Qnil;
9496+
9497+ if ((argc < 0) || (argc > 0)) {
9498+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9499+ }
9500+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
9501+ if (!SWIG_IsOK(res1)) {
9502+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageHeader *","ContIMOD", 1, self ));
9503+ }
9504+ arg1 = (mrcImageHeader *)(argp1);
9505+ result = (_mrcImageHeaderIMOD *)& ((arg1)->ContIMOD);
9506+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__mrcImageHeaderIMOD, 0 | 0 );
9507+ return vresult;
9508+fail:
9509+ return Qnil;
9510+}
9511+
9512+
9513+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
9514+SWIGINTERN VALUE
9515+_wrap_mrcImageHeader_allocate(VALUE self) {
9516+#else
9517+ SWIGINTERN VALUE
9518+ _wrap_mrcImageHeader_allocate(int argc, VALUE *argv, VALUE self) {
9519+#endif
9520+
9521+
9522+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_mrcImageHeader);
9523+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
9524+ rb_obj_call_init(vresult, argc, argv);
9525+#endif
9526+ return vresult;
9527+ }
9528+
9529+
9530+SWIGINTERN VALUE
9531+_wrap_new_mrcImageHeader(int argc, VALUE *argv, VALUE self) {
9532+ mrcImageHeader *result = 0 ;
9533+
9534+ if ((argc < 0) || (argc > 0)) {
9535+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9536+ }
9537+ result = (mrcImageHeader *)calloc(1, sizeof(mrcImageHeader));
9538+ DATA_PTR(self) = result;
9539+ return self;
9540+fail:
9541+ return Qnil;
9542+}
9543+
9544+
9545+SWIGINTERN void
9546+free_mrcImageHeader(mrcImageHeader *arg1) {
9547+ free((char *) arg1);
9548+}
9549+
9550+swig_class SwigClass_FEIextendedHeader;
9551+
9552+SWIGINTERN VALUE
9553+_wrap__FEIextendedHeader_aTilt_set(int argc, VALUE *argv, VALUE self) {
9554+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9555+ mrcImageParaTypeReal arg2 ;
9556+ void *argp1 = 0 ;
9557+ int res1 = 0 ;
9558+ float val2 ;
9559+ int ecode2 = 0 ;
9560+
9561+ if ((argc < 1) || (argc > 1)) {
9562+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9563+ }
9564+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9565+ if (!SWIG_IsOK(res1)) {
9566+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","aTilt", 1, self ));
9567+ }
9568+ arg1 = (_FEIextendedHeader *)(argp1);
9569+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9570+ if (!SWIG_IsOK(ecode2)) {
9571+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","aTilt", 2, argv[0] ));
9572+ }
9573+ arg2 = (mrcImageParaTypeReal)(val2);
9574+ if (arg1) (arg1)->aTilt = arg2;
9575+ return Qnil;
9576+fail:
9577+ return Qnil;
9578+}
9579+
9580+
9581+SWIGINTERN VALUE
9582+_wrap__FEIextendedHeader_aTilt_get(int argc, VALUE *argv, VALUE self) {
9583+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9584+ void *argp1 = 0 ;
9585+ int res1 = 0 ;
9586+ mrcImageParaTypeReal result;
9587+ VALUE vresult = Qnil;
9588+
9589+ if ((argc < 0) || (argc > 0)) {
9590+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9591+ }
9592+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9593+ if (!SWIG_IsOK(res1)) {
9594+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","aTilt", 1, self ));
9595+ }
9596+ arg1 = (_FEIextendedHeader *)(argp1);
9597+ result = (mrcImageParaTypeReal) ((arg1)->aTilt);
9598+ vresult = SWIG_From_float((float)(result));
9599+ return vresult;
9600+fail:
9601+ return Qnil;
9602+}
9603+
9604+
9605+SWIGINTERN VALUE
9606+_wrap__FEIextendedHeader_bTilt_set(int argc, VALUE *argv, VALUE self) {
9607+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9608+ mrcImageParaTypeReal arg2 ;
9609+ void *argp1 = 0 ;
9610+ int res1 = 0 ;
9611+ float val2 ;
9612+ int ecode2 = 0 ;
9613+
9614+ if ((argc < 1) || (argc > 1)) {
9615+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9616+ }
9617+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9618+ if (!SWIG_IsOK(res1)) {
9619+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","bTilt", 1, self ));
9620+ }
9621+ arg1 = (_FEIextendedHeader *)(argp1);
9622+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9623+ if (!SWIG_IsOK(ecode2)) {
9624+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","bTilt", 2, argv[0] ));
9625+ }
9626+ arg2 = (mrcImageParaTypeReal)(val2);
9627+ if (arg1) (arg1)->bTilt = arg2;
9628+ return Qnil;
9629+fail:
9630+ return Qnil;
9631+}
9632+
9633+
9634+SWIGINTERN VALUE
9635+_wrap__FEIextendedHeader_bTilt_get(int argc, VALUE *argv, VALUE self) {
9636+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9637+ void *argp1 = 0 ;
9638+ int res1 = 0 ;
9639+ mrcImageParaTypeReal result;
9640+ VALUE vresult = Qnil;
9641+
9642+ if ((argc < 0) || (argc > 0)) {
9643+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9644+ }
9645+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9646+ if (!SWIG_IsOK(res1)) {
9647+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","bTilt", 1, self ));
9648+ }
9649+ arg1 = (_FEIextendedHeader *)(argp1);
9650+ result = (mrcImageParaTypeReal) ((arg1)->bTilt);
9651+ vresult = SWIG_From_float((float)(result));
9652+ return vresult;
9653+fail:
9654+ return Qnil;
9655+}
9656+
9657+
9658+SWIGINTERN VALUE
9659+_wrap__FEIextendedHeader_xStage_set(int argc, VALUE *argv, VALUE self) {
9660+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9661+ mrcImageParaTypeReal arg2 ;
9662+ void *argp1 = 0 ;
9663+ int res1 = 0 ;
9664+ float val2 ;
9665+ int ecode2 = 0 ;
9666+
9667+ if ((argc < 1) || (argc > 1)) {
9668+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9669+ }
9670+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9671+ if (!SWIG_IsOK(res1)) {
9672+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","xStage", 1, self ));
9673+ }
9674+ arg1 = (_FEIextendedHeader *)(argp1);
9675+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9676+ if (!SWIG_IsOK(ecode2)) {
9677+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","xStage", 2, argv[0] ));
9678+ }
9679+ arg2 = (mrcImageParaTypeReal)(val2);
9680+ if (arg1) (arg1)->xStage = arg2;
9681+ return Qnil;
9682+fail:
9683+ return Qnil;
9684+}
9685+
9686+
9687+SWIGINTERN VALUE
9688+_wrap__FEIextendedHeader_xStage_get(int argc, VALUE *argv, VALUE self) {
9689+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9690+ void *argp1 = 0 ;
9691+ int res1 = 0 ;
9692+ mrcImageParaTypeReal result;
9693+ VALUE vresult = Qnil;
9694+
9695+ if ((argc < 0) || (argc > 0)) {
9696+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9697+ }
9698+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9699+ if (!SWIG_IsOK(res1)) {
9700+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","xStage", 1, self ));
9701+ }
9702+ arg1 = (_FEIextendedHeader *)(argp1);
9703+ result = (mrcImageParaTypeReal) ((arg1)->xStage);
9704+ vresult = SWIG_From_float((float)(result));
9705+ return vresult;
9706+fail:
9707+ return Qnil;
9708+}
9709+
9710+
9711+SWIGINTERN VALUE
9712+_wrap__FEIextendedHeader_yStage_set(int argc, VALUE *argv, VALUE self) {
9713+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9714+ mrcImageParaTypeReal arg2 ;
9715+ void *argp1 = 0 ;
9716+ int res1 = 0 ;
9717+ float val2 ;
9718+ int ecode2 = 0 ;
9719+
9720+ if ((argc < 1) || (argc > 1)) {
9721+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9722+ }
9723+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9724+ if (!SWIG_IsOK(res1)) {
9725+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","yStage", 1, self ));
9726+ }
9727+ arg1 = (_FEIextendedHeader *)(argp1);
9728+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9729+ if (!SWIG_IsOK(ecode2)) {
9730+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","yStage", 2, argv[0] ));
9731+ }
9732+ arg2 = (mrcImageParaTypeReal)(val2);
9733+ if (arg1) (arg1)->yStage = arg2;
9734+ return Qnil;
9735+fail:
9736+ return Qnil;
9737+}
9738+
9739+
9740+SWIGINTERN VALUE
9741+_wrap__FEIextendedHeader_yStage_get(int argc, VALUE *argv, VALUE self) {
9742+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9743+ void *argp1 = 0 ;
9744+ int res1 = 0 ;
9745+ mrcImageParaTypeReal result;
9746+ VALUE vresult = Qnil;
9747+
9748+ if ((argc < 0) || (argc > 0)) {
9749+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9750+ }
9751+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9752+ if (!SWIG_IsOK(res1)) {
9753+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","yStage", 1, self ));
9754+ }
9755+ arg1 = (_FEIextendedHeader *)(argp1);
9756+ result = (mrcImageParaTypeReal) ((arg1)->yStage);
9757+ vresult = SWIG_From_float((float)(result));
9758+ return vresult;
9759+fail:
9760+ return Qnil;
9761+}
9762+
9763+
9764+SWIGINTERN VALUE
9765+_wrap__FEIextendedHeader_zStage_set(int argc, VALUE *argv, VALUE self) {
9766+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9767+ mrcImageParaTypeReal arg2 ;
9768+ void *argp1 = 0 ;
9769+ int res1 = 0 ;
9770+ float val2 ;
9771+ int ecode2 = 0 ;
9772+
9773+ if ((argc < 1) || (argc > 1)) {
9774+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9775+ }
9776+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9777+ if (!SWIG_IsOK(res1)) {
9778+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","zStage", 1, self ));
9779+ }
9780+ arg1 = (_FEIextendedHeader *)(argp1);
9781+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9782+ if (!SWIG_IsOK(ecode2)) {
9783+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","zStage", 2, argv[0] ));
9784+ }
9785+ arg2 = (mrcImageParaTypeReal)(val2);
9786+ if (arg1) (arg1)->zStage = arg2;
9787+ return Qnil;
9788+fail:
9789+ return Qnil;
9790+}
9791+
9792+
9793+SWIGINTERN VALUE
9794+_wrap__FEIextendedHeader_zStage_get(int argc, VALUE *argv, VALUE self) {
9795+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9796+ void *argp1 = 0 ;
9797+ int res1 = 0 ;
9798+ mrcImageParaTypeReal result;
9799+ VALUE vresult = Qnil;
9800+
9801+ if ((argc < 0) || (argc > 0)) {
9802+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9803+ }
9804+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9805+ if (!SWIG_IsOK(res1)) {
9806+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","zStage", 1, self ));
9807+ }
9808+ arg1 = (_FEIextendedHeader *)(argp1);
9809+ result = (mrcImageParaTypeReal) ((arg1)->zStage);
9810+ vresult = SWIG_From_float((float)(result));
9811+ return vresult;
9812+fail:
9813+ return Qnil;
9814+}
9815+
9816+
9817+SWIGINTERN VALUE
9818+_wrap__FEIextendedHeader_xShift_set(int argc, VALUE *argv, VALUE self) {
9819+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9820+ mrcImageParaTypeReal arg2 ;
9821+ void *argp1 = 0 ;
9822+ int res1 = 0 ;
9823+ float val2 ;
9824+ int ecode2 = 0 ;
9825+
9826+ if ((argc < 1) || (argc > 1)) {
9827+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9828+ }
9829+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9830+ if (!SWIG_IsOK(res1)) {
9831+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","xShift", 1, self ));
9832+ }
9833+ arg1 = (_FEIextendedHeader *)(argp1);
9834+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9835+ if (!SWIG_IsOK(ecode2)) {
9836+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","xShift", 2, argv[0] ));
9837+ }
9838+ arg2 = (mrcImageParaTypeReal)(val2);
9839+ if (arg1) (arg1)->xShift = arg2;
9840+ return Qnil;
9841+fail:
9842+ return Qnil;
9843+}
9844+
9845+
9846+SWIGINTERN VALUE
9847+_wrap__FEIextendedHeader_xShift_get(int argc, VALUE *argv, VALUE self) {
9848+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9849+ void *argp1 = 0 ;
9850+ int res1 = 0 ;
9851+ mrcImageParaTypeReal result;
9852+ VALUE vresult = Qnil;
9853+
9854+ if ((argc < 0) || (argc > 0)) {
9855+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9856+ }
9857+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9858+ if (!SWIG_IsOK(res1)) {
9859+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","xShift", 1, self ));
9860+ }
9861+ arg1 = (_FEIextendedHeader *)(argp1);
9862+ result = (mrcImageParaTypeReal) ((arg1)->xShift);
9863+ vresult = SWIG_From_float((float)(result));
9864+ return vresult;
9865+fail:
9866+ return Qnil;
9867+}
9868+
9869+
9870+SWIGINTERN VALUE
9871+_wrap__FEIextendedHeader_yShift_set(int argc, VALUE *argv, VALUE self) {
9872+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9873+ mrcImageParaTypeReal arg2 ;
9874+ void *argp1 = 0 ;
9875+ int res1 = 0 ;
9876+ float val2 ;
9877+ int ecode2 = 0 ;
9878+
9879+ if ((argc < 1) || (argc > 1)) {
9880+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9881+ }
9882+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9883+ if (!SWIG_IsOK(res1)) {
9884+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","yShift", 1, self ));
9885+ }
9886+ arg1 = (_FEIextendedHeader *)(argp1);
9887+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9888+ if (!SWIG_IsOK(ecode2)) {
9889+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","yShift", 2, argv[0] ));
9890+ }
9891+ arg2 = (mrcImageParaTypeReal)(val2);
9892+ if (arg1) (arg1)->yShift = arg2;
9893+ return Qnil;
9894+fail:
9895+ return Qnil;
9896+}
9897+
9898+
9899+SWIGINTERN VALUE
9900+_wrap__FEIextendedHeader_yShift_get(int argc, VALUE *argv, VALUE self) {
9901+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9902+ void *argp1 = 0 ;
9903+ int res1 = 0 ;
9904+ mrcImageParaTypeReal result;
9905+ VALUE vresult = Qnil;
9906+
9907+ if ((argc < 0) || (argc > 0)) {
9908+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9909+ }
9910+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9911+ if (!SWIG_IsOK(res1)) {
9912+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","yShift", 1, self ));
9913+ }
9914+ arg1 = (_FEIextendedHeader *)(argp1);
9915+ result = (mrcImageParaTypeReal) ((arg1)->yShift);
9916+ vresult = SWIG_From_float((float)(result));
9917+ return vresult;
9918+fail:
9919+ return Qnil;
9920+}
9921+
9922+
9923+SWIGINTERN VALUE
9924+_wrap__FEIextendedHeader_defocus_set(int argc, VALUE *argv, VALUE self) {
9925+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9926+ mrcImageParaTypeReal arg2 ;
9927+ void *argp1 = 0 ;
9928+ int res1 = 0 ;
9929+ float val2 ;
9930+ int ecode2 = 0 ;
9931+
9932+ if ((argc < 1) || (argc > 1)) {
9933+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9934+ }
9935+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9936+ if (!SWIG_IsOK(res1)) {
9937+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","defocus", 1, self ));
9938+ }
9939+ arg1 = (_FEIextendedHeader *)(argp1);
9940+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9941+ if (!SWIG_IsOK(ecode2)) {
9942+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","defocus", 2, argv[0] ));
9943+ }
9944+ arg2 = (mrcImageParaTypeReal)(val2);
9945+ if (arg1) (arg1)->defocus = arg2;
9946+ return Qnil;
9947+fail:
9948+ return Qnil;
9949+}
9950+
9951+
9952+SWIGINTERN VALUE
9953+_wrap__FEIextendedHeader_defocus_get(int argc, VALUE *argv, VALUE self) {
9954+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9955+ void *argp1 = 0 ;
9956+ int res1 = 0 ;
9957+ mrcImageParaTypeReal result;
9958+ VALUE vresult = Qnil;
9959+
9960+ if ((argc < 0) || (argc > 0)) {
9961+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
9962+ }
9963+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9964+ if (!SWIG_IsOK(res1)) {
9965+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","defocus", 1, self ));
9966+ }
9967+ arg1 = (_FEIextendedHeader *)(argp1);
9968+ result = (mrcImageParaTypeReal) ((arg1)->defocus);
9969+ vresult = SWIG_From_float((float)(result));
9970+ return vresult;
9971+fail:
9972+ return Qnil;
9973+}
9974+
9975+
9976+SWIGINTERN VALUE
9977+_wrap__FEIextendedHeader_expTime_set(int argc, VALUE *argv, VALUE self) {
9978+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
9979+ mrcImageParaTypeReal arg2 ;
9980+ void *argp1 = 0 ;
9981+ int res1 = 0 ;
9982+ float val2 ;
9983+ int ecode2 = 0 ;
9984+
9985+ if ((argc < 1) || (argc > 1)) {
9986+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
9987+ }
9988+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
9989+ if (!SWIG_IsOK(res1)) {
9990+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","expTime", 1, self ));
9991+ }
9992+ arg1 = (_FEIextendedHeader *)(argp1);
9993+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
9994+ if (!SWIG_IsOK(ecode2)) {
9995+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","expTime", 2, argv[0] ));
9996+ }
9997+ arg2 = (mrcImageParaTypeReal)(val2);
9998+ if (arg1) (arg1)->expTime = arg2;
9999+ return Qnil;
10000+fail:
10001+ return Qnil;
10002+}
10003+
10004+
10005+SWIGINTERN VALUE
10006+_wrap__FEIextendedHeader_expTime_get(int argc, VALUE *argv, VALUE self) {
10007+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10008+ void *argp1 = 0 ;
10009+ int res1 = 0 ;
10010+ mrcImageParaTypeReal result;
10011+ VALUE vresult = Qnil;
10012+
10013+ if ((argc < 0) || (argc > 0)) {
10014+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10015+ }
10016+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10017+ if (!SWIG_IsOK(res1)) {
10018+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","expTime", 1, self ));
10019+ }
10020+ arg1 = (_FEIextendedHeader *)(argp1);
10021+ result = (mrcImageParaTypeReal) ((arg1)->expTime);
10022+ vresult = SWIG_From_float((float)(result));
10023+ return vresult;
10024+fail:
10025+ return Qnil;
10026+}
10027+
10028+
10029+SWIGINTERN VALUE
10030+_wrap__FEIextendedHeader_mean_set(int argc, VALUE *argv, VALUE self) {
10031+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10032+ mrcImageParaTypeReal arg2 ;
10033+ void *argp1 = 0 ;
10034+ int res1 = 0 ;
10035+ float val2 ;
10036+ int ecode2 = 0 ;
10037+
10038+ if ((argc < 1) || (argc > 1)) {
10039+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10040+ }
10041+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10042+ if (!SWIG_IsOK(res1)) {
10043+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","mean", 1, self ));
10044+ }
10045+ arg1 = (_FEIextendedHeader *)(argp1);
10046+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10047+ if (!SWIG_IsOK(ecode2)) {
10048+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","mean", 2, argv[0] ));
10049+ }
10050+ arg2 = (mrcImageParaTypeReal)(val2);
10051+ if (arg1) (arg1)->mean = arg2;
10052+ return Qnil;
10053+fail:
10054+ return Qnil;
10055+}
10056+
10057+
10058+SWIGINTERN VALUE
10059+_wrap__FEIextendedHeader_mean_get(int argc, VALUE *argv, VALUE self) {
10060+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10061+ void *argp1 = 0 ;
10062+ int res1 = 0 ;
10063+ mrcImageParaTypeReal result;
10064+ VALUE vresult = Qnil;
10065+
10066+ if ((argc < 0) || (argc > 0)) {
10067+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10068+ }
10069+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10070+ if (!SWIG_IsOK(res1)) {
10071+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","mean", 1, self ));
10072+ }
10073+ arg1 = (_FEIextendedHeader *)(argp1);
10074+ result = (mrcImageParaTypeReal) ((arg1)->mean);
10075+ vresult = SWIG_From_float((float)(result));
10076+ return vresult;
10077+fail:
10078+ return Qnil;
10079+}
10080+
10081+
10082+SWIGINTERN VALUE
10083+_wrap__FEIextendedHeader_tiltAxis_set(int argc, VALUE *argv, VALUE self) {
10084+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10085+ mrcImageParaTypeReal arg2 ;
10086+ void *argp1 = 0 ;
10087+ int res1 = 0 ;
10088+ float val2 ;
10089+ int ecode2 = 0 ;
10090+
10091+ if ((argc < 1) || (argc > 1)) {
10092+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10093+ }
10094+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10095+ if (!SWIG_IsOK(res1)) {
10096+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","tiltAxis", 1, self ));
10097+ }
10098+ arg1 = (_FEIextendedHeader *)(argp1);
10099+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10100+ if (!SWIG_IsOK(ecode2)) {
10101+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","tiltAxis", 2, argv[0] ));
10102+ }
10103+ arg2 = (mrcImageParaTypeReal)(val2);
10104+ if (arg1) (arg1)->tiltAxis = arg2;
10105+ return Qnil;
10106+fail:
10107+ return Qnil;
10108+}
10109+
10110+
10111+SWIGINTERN VALUE
10112+_wrap__FEIextendedHeader_tiltAxis_get(int argc, VALUE *argv, VALUE self) {
10113+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10114+ void *argp1 = 0 ;
10115+ int res1 = 0 ;
10116+ mrcImageParaTypeReal result;
10117+ VALUE vresult = Qnil;
10118+
10119+ if ((argc < 0) || (argc > 0)) {
10120+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10121+ }
10122+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10123+ if (!SWIG_IsOK(res1)) {
10124+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","tiltAxis", 1, self ));
10125+ }
10126+ arg1 = (_FEIextendedHeader *)(argp1);
10127+ result = (mrcImageParaTypeReal) ((arg1)->tiltAxis);
10128+ vresult = SWIG_From_float((float)(result));
10129+ return vresult;
10130+fail:
10131+ return Qnil;
10132+}
10133+
10134+
10135+SWIGINTERN VALUE
10136+_wrap__FEIextendedHeader_pixelSize_set(int argc, VALUE *argv, VALUE self) {
10137+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10138+ mrcImageParaTypeReal arg2 ;
10139+ void *argp1 = 0 ;
10140+ int res1 = 0 ;
10141+ float val2 ;
10142+ int ecode2 = 0 ;
10143+
10144+ if ((argc < 1) || (argc > 1)) {
10145+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10146+ }
10147+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10148+ if (!SWIG_IsOK(res1)) {
10149+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","pixelSize", 1, self ));
10150+ }
10151+ arg1 = (_FEIextendedHeader *)(argp1);
10152+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10153+ if (!SWIG_IsOK(ecode2)) {
10154+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","pixelSize", 2, argv[0] ));
10155+ }
10156+ arg2 = (mrcImageParaTypeReal)(val2);
10157+ if (arg1) (arg1)->pixelSize = arg2;
10158+ return Qnil;
10159+fail:
10160+ return Qnil;
10161+}
10162+
10163+
10164+SWIGINTERN VALUE
10165+_wrap__FEIextendedHeader_pixelSize_get(int argc, VALUE *argv, VALUE self) {
10166+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10167+ void *argp1 = 0 ;
10168+ int res1 = 0 ;
10169+ mrcImageParaTypeReal result;
10170+ VALUE vresult = Qnil;
10171+
10172+ if ((argc < 0) || (argc > 0)) {
10173+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10174+ }
10175+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10176+ if (!SWIG_IsOK(res1)) {
10177+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","pixelSize", 1, self ));
10178+ }
10179+ arg1 = (_FEIextendedHeader *)(argp1);
10180+ result = (mrcImageParaTypeReal) ((arg1)->pixelSize);
10181+ vresult = SWIG_From_float((float)(result));
10182+ return vresult;
10183+fail:
10184+ return Qnil;
10185+}
10186+
10187+
10188+SWIGINTERN VALUE
10189+_wrap__FEIextendedHeader_magnification_set(int argc, VALUE *argv, VALUE self) {
10190+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10191+ mrcImageParaTypeReal arg2 ;
10192+ void *argp1 = 0 ;
10193+ int res1 = 0 ;
10194+ float val2 ;
10195+ int ecode2 = 0 ;
10196+
10197+ if ((argc < 1) || (argc > 1)) {
10198+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10199+ }
10200+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10201+ if (!SWIG_IsOK(res1)) {
10202+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","magnification", 1, self ));
10203+ }
10204+ arg1 = (_FEIextendedHeader *)(argp1);
10205+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10206+ if (!SWIG_IsOK(ecode2)) {
10207+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","magnification", 2, argv[0] ));
10208+ }
10209+ arg2 = (mrcImageParaTypeReal)(val2);
10210+ if (arg1) (arg1)->magnification = arg2;
10211+ return Qnil;
10212+fail:
10213+ return Qnil;
10214+}
10215+
10216+
10217+SWIGINTERN VALUE
10218+_wrap__FEIextendedHeader_magnification_get(int argc, VALUE *argv, VALUE self) {
10219+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10220+ void *argp1 = 0 ;
10221+ int res1 = 0 ;
10222+ mrcImageParaTypeReal result;
10223+ VALUE vresult = Qnil;
10224+
10225+ if ((argc < 0) || (argc > 0)) {
10226+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10227+ }
10228+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10229+ if (!SWIG_IsOK(res1)) {
10230+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","magnification", 1, self ));
10231+ }
10232+ arg1 = (_FEIextendedHeader *)(argp1);
10233+ result = (mrcImageParaTypeReal) ((arg1)->magnification);
10234+ vresult = SWIG_From_float((float)(result));
10235+ return vresult;
10236+fail:
10237+ return Qnil;
10238+}
10239+
10240+
10241+SWIGINTERN VALUE
10242+_wrap__FEIextendedHeader_ht_set(int argc, VALUE *argv, VALUE self) {
10243+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10244+ mrcImageParaTypeReal arg2 ;
10245+ void *argp1 = 0 ;
10246+ int res1 = 0 ;
10247+ float val2 ;
10248+ int ecode2 = 0 ;
10249+
10250+ if ((argc < 1) || (argc > 1)) {
10251+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10252+ }
10253+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10254+ if (!SWIG_IsOK(res1)) {
10255+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","ht", 1, self ));
10256+ }
10257+ arg1 = (_FEIextendedHeader *)(argp1);
10258+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10259+ if (!SWIG_IsOK(ecode2)) {
10260+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","ht", 2, argv[0] ));
10261+ }
10262+ arg2 = (mrcImageParaTypeReal)(val2);
10263+ if (arg1) (arg1)->ht = arg2;
10264+ return Qnil;
10265+fail:
10266+ return Qnil;
10267+}
10268+
10269+
10270+SWIGINTERN VALUE
10271+_wrap__FEIextendedHeader_ht_get(int argc, VALUE *argv, VALUE self) {
10272+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10273+ void *argp1 = 0 ;
10274+ int res1 = 0 ;
10275+ mrcImageParaTypeReal result;
10276+ VALUE vresult = Qnil;
10277+
10278+ if ((argc < 0) || (argc > 0)) {
10279+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10280+ }
10281+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10282+ if (!SWIG_IsOK(res1)) {
10283+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","ht", 1, self ));
10284+ }
10285+ arg1 = (_FEIextendedHeader *)(argp1);
10286+ result = (mrcImageParaTypeReal) ((arg1)->ht);
10287+ vresult = SWIG_From_float((float)(result));
10288+ return vresult;
10289+fail:
10290+ return Qnil;
10291+}
10292+
10293+
10294+SWIGINTERN VALUE
10295+_wrap__FEIextendedHeader_binning_set(int argc, VALUE *argv, VALUE self) {
10296+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10297+ mrcImageParaTypeReal arg2 ;
10298+ void *argp1 = 0 ;
10299+ int res1 = 0 ;
10300+ float val2 ;
10301+ int ecode2 = 0 ;
10302+
10303+ if ((argc < 1) || (argc > 1)) {
10304+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10305+ }
10306+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10307+ if (!SWIG_IsOK(res1)) {
10308+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","binning", 1, self ));
10309+ }
10310+ arg1 = (_FEIextendedHeader *)(argp1);
10311+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10312+ if (!SWIG_IsOK(ecode2)) {
10313+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","binning", 2, argv[0] ));
10314+ }
10315+ arg2 = (mrcImageParaTypeReal)(val2);
10316+ if (arg1) (arg1)->binning = arg2;
10317+ return Qnil;
10318+fail:
10319+ return Qnil;
10320+}
10321+
10322+
10323+SWIGINTERN VALUE
10324+_wrap__FEIextendedHeader_binning_get(int argc, VALUE *argv, VALUE self) {
10325+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10326+ void *argp1 = 0 ;
10327+ int res1 = 0 ;
10328+ mrcImageParaTypeReal result;
10329+ VALUE vresult = Qnil;
10330+
10331+ if ((argc < 0) || (argc > 0)) {
10332+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10333+ }
10334+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10335+ if (!SWIG_IsOK(res1)) {
10336+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","binning", 1, self ));
10337+ }
10338+ arg1 = (_FEIextendedHeader *)(argp1);
10339+ result = (mrcImageParaTypeReal) ((arg1)->binning);
10340+ vresult = SWIG_From_float((float)(result));
10341+ return vresult;
10342+fail:
10343+ return Qnil;
10344+}
10345+
10346+
10347+SWIGINTERN VALUE
10348+_wrap__FEIextendedHeader_appliedDefocus_set(int argc, VALUE *argv, VALUE self) {
10349+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10350+ mrcImageParaTypeReal arg2 ;
10351+ void *argp1 = 0 ;
10352+ int res1 = 0 ;
10353+ float val2 ;
10354+ int ecode2 = 0 ;
10355+
10356+ if ((argc < 1) || (argc > 1)) {
10357+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10358+ }
10359+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10360+ if (!SWIG_IsOK(res1)) {
10361+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","appliedDefocus", 1, self ));
10362+ }
10363+ arg1 = (_FEIextendedHeader *)(argp1);
10364+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10365+ if (!SWIG_IsOK(ecode2)) {
10366+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","appliedDefocus", 2, argv[0] ));
10367+ }
10368+ arg2 = (mrcImageParaTypeReal)(val2);
10369+ if (arg1) (arg1)->appliedDefocus = arg2;
10370+ return Qnil;
10371+fail:
10372+ return Qnil;
10373+}
10374+
10375+
10376+SWIGINTERN VALUE
10377+_wrap__FEIextendedHeader_appliedDefocus_get(int argc, VALUE *argv, VALUE self) {
10378+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10379+ void *argp1 = 0 ;
10380+ int res1 = 0 ;
10381+ mrcImageParaTypeReal result;
10382+ VALUE vresult = Qnil;
10383+
10384+ if ((argc < 0) || (argc > 0)) {
10385+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10386+ }
10387+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10388+ if (!SWIG_IsOK(res1)) {
10389+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","appliedDefocus", 1, self ));
10390+ }
10391+ arg1 = (_FEIextendedHeader *)(argp1);
10392+ result = (mrcImageParaTypeReal) ((arg1)->appliedDefocus);
10393+ vresult = SWIG_From_float((float)(result));
10394+ return vresult;
10395+fail:
10396+ return Qnil;
10397+}
10398+
10399+
10400+SWIGINTERN VALUE
10401+_wrap__FEIextendedHeader_reminder_set(int argc, VALUE *argv, VALUE self) {
10402+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10403+ mrcImageParaTypeReal *arg2 ;
10404+ void *argp1 = 0 ;
10405+ int res1 = 0 ;
10406+ void *argp2 = 0 ;
10407+ int res2 = 0 ;
10408+
10409+ if ((argc < 1) || (argc > 1)) {
10410+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10411+ }
10412+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10413+ if (!SWIG_IsOK(res1)) {
10414+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","reminder", 1, self ));
10415+ }
10416+ arg1 = (_FEIextendedHeader *)(argp1);
10417+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
10418+ if (!SWIG_IsOK(res2)) {
10419+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [(128)/4-16]","reminder", 2, argv[0] ));
10420+ }
10421+ arg2 = (mrcImageParaTypeReal *)(argp2);
10422+ {
10423+ if (arg2) {
10424+ size_t ii = 0;
10425+ for (; ii < (size_t)(128)/4-16; ++ii) arg1->reminder[ii] = arg2[ii];
10426+ } else {
10427+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""reminder""' of type '""mrcImageParaTypeReal [(128)/4-16]""'");
10428+ }
10429+ }
10430+ return Qnil;
10431+fail:
10432+ return Qnil;
10433+}
10434+
10435+
10436+SWIGINTERN VALUE
10437+_wrap__FEIextendedHeader_reminder_get(int argc, VALUE *argv, VALUE self) {
10438+ _FEIextendedHeader *arg1 = (_FEIextendedHeader *) 0 ;
10439+ void *argp1 = 0 ;
10440+ int res1 = 0 ;
10441+ mrcImageParaTypeReal *result = 0 ;
10442+ VALUE vresult = Qnil;
10443+
10444+ if ((argc < 0) || (argc > 0)) {
10445+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10446+ }
10447+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10448+ if (!SWIG_IsOK(res1)) {
10449+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_FEIextendedHeader *","reminder", 1, self ));
10450+ }
10451+ arg1 = (_FEIextendedHeader *)(argp1);
10452+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->reminder);
10453+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
10454+ return vresult;
10455+fail:
10456+ return Qnil;
10457+}
10458+
10459+
10460+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
10461+SWIGINTERN VALUE
10462+_wrap__FEIextendedHeader_allocate(VALUE self) {
10463+#else
10464+ SWIGINTERN VALUE
10465+ _wrap__FEIextendedHeader_allocate(int argc, VALUE *argv, VALUE self) {
10466+#endif
10467+
10468+
10469+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p__FEIextendedHeader);
10470+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
10471+ rb_obj_call_init(vresult, argc, argv);
10472+#endif
10473+ return vresult;
10474+ }
10475+
10476+
10477+SWIGINTERN VALUE
10478+_wrap_new__FEIextendedHeader(int argc, VALUE *argv, VALUE self) {
10479+ _FEIextendedHeader *result = 0 ;
10480+
10481+ if ((argc < 0) || (argc > 0)) {
10482+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10483+ }
10484+ result = (_FEIextendedHeader *)calloc(1, sizeof(_FEIextendedHeader));
10485+ DATA_PTR(self) = result;
10486+ return self;
10487+fail:
10488+ return Qnil;
10489+}
10490+
10491+
10492+SWIGINTERN void
10493+free__FEIextendedHeader(_FEIextendedHeader *arg1) {
10494+ free((char *) arg1);
10495+}
10496+
10497+swig_class SwigClassFEIextendedHeader;
10498+
10499+SWIGINTERN VALUE
10500+_wrap_FEIextendedHeader_Real_set(int argc, VALUE *argv, VALUE self) {
10501+ FEIextendedHeader *arg1 = (FEIextendedHeader *) 0 ;
10502+ mrcImageParaTypeReal *arg2 ;
10503+ void *argp1 = 0 ;
10504+ int res1 = 0 ;
10505+ void *argp2 = 0 ;
10506+ int res2 = 0 ;
10507+
10508+ if ((argc < 1) || (argc > 1)) {
10509+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10510+ }
10511+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FEIextendedHeader, 0 | 0 );
10512+ if (!SWIG_IsOK(res1)) {
10513+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FEIextendedHeader *","Real", 1, self ));
10514+ }
10515+ arg1 = (FEIextendedHeader *)(argp1);
10516+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
10517+ if (!SWIG_IsOK(res2)) {
10518+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [(128)/4]","Real", 2, argv[0] ));
10519+ }
10520+ arg2 = (mrcImageParaTypeReal *)(argp2);
10521+ {
10522+ if (arg2) {
10523+ size_t ii = 0;
10524+ for (; ii < (size_t)(128)/4; ++ii) arg1->Real[ii] = arg2[ii];
10525+ } else {
10526+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Real""' of type '""mrcImageParaTypeReal [(128)/4]""'");
10527+ }
10528+ }
10529+ return Qnil;
10530+fail:
10531+ return Qnil;
10532+}
10533+
10534+
10535+SWIGINTERN VALUE
10536+_wrap_FEIextendedHeader_Real_get(int argc, VALUE *argv, VALUE self) {
10537+ FEIextendedHeader *arg1 = (FEIextendedHeader *) 0 ;
10538+ void *argp1 = 0 ;
10539+ int res1 = 0 ;
10540+ mrcImageParaTypeReal *result = 0 ;
10541+ VALUE vresult = Qnil;
10542+
10543+ if ((argc < 0) || (argc > 0)) {
10544+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10545+ }
10546+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FEIextendedHeader, 0 | 0 );
10547+ if (!SWIG_IsOK(res1)) {
10548+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FEIextendedHeader *","Real", 1, self ));
10549+ }
10550+ arg1 = (FEIextendedHeader *)(argp1);
10551+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->Real);
10552+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
10553+ return vresult;
10554+fail:
10555+ return Qnil;
10556+}
10557+
10558+
10559+SWIGINTERN VALUE
10560+_wrap_FEIextendedHeader_Cont_set(int argc, VALUE *argv, VALUE self) {
10561+ FEIextendedHeader *arg1 = (FEIextendedHeader *) 0 ;
10562+ _FEIextendedHeader *arg2 = (_FEIextendedHeader *) 0 ;
10563+ void *argp1 = 0 ;
10564+ int res1 = 0 ;
10565+ void *argp2 = 0 ;
10566+ int res2 = 0 ;
10567+
10568+ if ((argc < 1) || (argc > 1)) {
10569+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10570+ }
10571+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FEIextendedHeader, 0 | 0 );
10572+ if (!SWIG_IsOK(res1)) {
10573+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FEIextendedHeader *","Cont", 1, self ));
10574+ }
10575+ arg1 = (FEIextendedHeader *)(argp1);
10576+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10577+ if (!SWIG_IsOK(res2)) {
10578+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_FEIextendedHeader *","Cont", 2, argv[0] ));
10579+ }
10580+ arg2 = (_FEIextendedHeader *)(argp2);
10581+ if (arg1) (arg1)->Cont = *arg2;
10582+ return Qnil;
10583+fail:
10584+ return Qnil;
10585+}
10586+
10587+
10588+SWIGINTERN VALUE
10589+_wrap_FEIextendedHeader_Cont_get(int argc, VALUE *argv, VALUE self) {
10590+ FEIextendedHeader *arg1 = (FEIextendedHeader *) 0 ;
10591+ void *argp1 = 0 ;
10592+ int res1 = 0 ;
10593+ _FEIextendedHeader *result = 0 ;
10594+ VALUE vresult = Qnil;
10595+
10596+ if ((argc < 0) || (argc > 0)) {
10597+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10598+ }
10599+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_FEIextendedHeader, 0 | 0 );
10600+ if (!SWIG_IsOK(res1)) {
10601+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FEIextendedHeader *","Cont", 1, self ));
10602+ }
10603+ arg1 = (FEIextendedHeader *)(argp1);
10604+ result = (_FEIextendedHeader *)& ((arg1)->Cont);
10605+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__FEIextendedHeader, 0 | 0 );
10606+ return vresult;
10607+fail:
10608+ return Qnil;
10609+}
10610+
10611+
10612+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
10613+SWIGINTERN VALUE
10614+_wrap_FEIextendedHeader_allocate(VALUE self) {
10615+#else
10616+ SWIGINTERN VALUE
10617+ _wrap_FEIextendedHeader_allocate(int argc, VALUE *argv, VALUE self) {
10618+#endif
10619+
10620+
10621+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_FEIextendedHeader);
10622+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
10623+ rb_obj_call_init(vresult, argc, argv);
10624+#endif
10625+ return vresult;
10626+ }
10627+
10628+
10629+SWIGINTERN VALUE
10630+_wrap_new_FEIextendedHeader(int argc, VALUE *argv, VALUE self) {
10631+ FEIextendedHeader *result = 0 ;
10632+
10633+ if ((argc < 0) || (argc > 0)) {
10634+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10635+ }
10636+ result = (FEIextendedHeader *)calloc(1, sizeof(FEIextendedHeader));
10637+ DATA_PTR(self) = result;
10638+ return self;
10639+fail:
10640+ return Qnil;
10641+}
10642+
10643+
10644+SWIGINTERN void
10645+free_FEIextendedHeader(FEIextendedHeader *arg1) {
10646+ free((char *) arg1);
10647+}
10648+
10649+swig_class SwigClass_mrcImageTailer;
10650+
10651+SWIGINTERN VALUE
10652+_wrap__mrcImageTailer_Code_set(int argc, VALUE *argv, VALUE self) {
10653+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10654+ char *arg2 ;
10655+ void *argp1 = 0 ;
10656+ int res1 = 0 ;
10657+ char temp2[4] ;
10658+ int res2 ;
10659+
10660+ if ((argc < 1) || (argc > 1)) {
10661+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10662+ }
10663+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10664+ if (!SWIG_IsOK(res1)) {
10665+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Code", 1, self ));
10666+ }
10667+ arg1 = (_mrcImageTailer *)(argp1);
10668+ res2 = SWIG_AsCharArray(argv[0], temp2, 4);
10669+ if (!SWIG_IsOK(res2)) {
10670+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [4]","Code", 2, argv[0] ));
10671+ }
10672+ arg2 = (char *)(temp2);
10673+ if (arg2) memcpy(arg1->Code,arg2,4*sizeof(char));
10674+ else memset(arg1->Code,0,4*sizeof(char));
10675+ return Qnil;
10676+fail:
10677+ return Qnil;
10678+}
10679+
10680+
10681+SWIGINTERN VALUE
10682+_wrap__mrcImageTailer_Code_get(int argc, VALUE *argv, VALUE self) {
10683+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10684+ void *argp1 = 0 ;
10685+ int res1 = 0 ;
10686+ char *result = 0 ;
10687+ VALUE vresult = Qnil;
10688+
10689+ if ((argc < 0) || (argc > 0)) {
10690+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10691+ }
10692+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10693+ if (!SWIG_IsOK(res1)) {
10694+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Code", 1, self ));
10695+ }
10696+ arg1 = (_mrcImageTailer *)(argp1);
10697+ result = (char *)(char *) ((arg1)->Code);
10698+ {
10699+ size_t size = 4;
10700+
10701+ while (size && (result[size - 1] == '\0')) --size;
10702+
10703+ vresult = SWIG_FromCharPtrAndSize(result, size);
10704+ }
10705+ return vresult;
10706+fail:
10707+ return Qnil;
10708+}
10709+
10710+
10711+SWIGINTERN VALUE
10712+_wrap__mrcImageTailer_Mode_set(int argc, VALUE *argv, VALUE self) {
10713+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10714+ mrcImageParaTypeInteger arg2 ;
10715+ void *argp1 = 0 ;
10716+ int res1 = 0 ;
10717+ int val2 ;
10718+ int ecode2 = 0 ;
10719+
10720+ if ((argc < 1) || (argc > 1)) {
10721+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10722+ }
10723+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10724+ if (!SWIG_IsOK(res1)) {
10725+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Mode", 1, self ));
10726+ }
10727+ arg1 = (_mrcImageTailer *)(argp1);
10728+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
10729+ if (!SWIG_IsOK(ecode2)) {
10730+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","Mode", 2, argv[0] ));
10731+ }
10732+ arg2 = (mrcImageParaTypeInteger)(val2);
10733+ if (arg1) (arg1)->Mode = arg2;
10734+ return Qnil;
10735+fail:
10736+ return Qnil;
10737+}
10738+
10739+
10740+SWIGINTERN VALUE
10741+_wrap__mrcImageTailer_Mode_get(int argc, VALUE *argv, VALUE self) {
10742+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10743+ void *argp1 = 0 ;
10744+ int res1 = 0 ;
10745+ mrcImageParaTypeInteger result;
10746+ VALUE vresult = Qnil;
10747+
10748+ if ((argc < 0) || (argc > 0)) {
10749+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10750+ }
10751+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10752+ if (!SWIG_IsOK(res1)) {
10753+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Mode", 1, self ));
10754+ }
10755+ arg1 = (_mrcImageTailer *)(argp1);
10756+ result = (mrcImageParaTypeInteger) ((arg1)->Mode);
10757+ vresult = SWIG_From_int((int)(result));
10758+ return vresult;
10759+fail:
10760+ return Qnil;
10761+}
10762+
10763+
10764+SWIGINTERN VALUE
10765+_wrap__mrcImageTailer_EulerAngleMode_set(int argc, VALUE *argv, VALUE self) {
10766+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10767+ char *arg2 ;
10768+ void *argp1 = 0 ;
10769+ int res1 = 0 ;
10770+ char temp2[4] ;
10771+ int res2 ;
10772+
10773+ if ((argc < 1) || (argc > 1)) {
10774+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10775+ }
10776+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10777+ if (!SWIG_IsOK(res1)) {
10778+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","EulerAngleMode", 1, self ));
10779+ }
10780+ arg1 = (_mrcImageTailer *)(argp1);
10781+ res2 = SWIG_AsCharArray(argv[0], temp2, 4);
10782+ if (!SWIG_IsOK(res2)) {
10783+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char [4]","EulerAngleMode", 2, argv[0] ));
10784+ }
10785+ arg2 = (char *)(temp2);
10786+ if (arg2) memcpy(arg1->EulerAngleMode,arg2,4*sizeof(char));
10787+ else memset(arg1->EulerAngleMode,0,4*sizeof(char));
10788+ return Qnil;
10789+fail:
10790+ return Qnil;
10791+}
10792+
10793+
10794+SWIGINTERN VALUE
10795+_wrap__mrcImageTailer_EulerAngleMode_get(int argc, VALUE *argv, VALUE self) {
10796+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10797+ void *argp1 = 0 ;
10798+ int res1 = 0 ;
10799+ char *result = 0 ;
10800+ VALUE vresult = Qnil;
10801+
10802+ if ((argc < 0) || (argc > 0)) {
10803+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10804+ }
10805+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10806+ if (!SWIG_IsOK(res1)) {
10807+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","EulerAngleMode", 1, self ));
10808+ }
10809+ arg1 = (_mrcImageTailer *)(argp1);
10810+ result = (char *)(char *) ((arg1)->EulerAngleMode);
10811+ {
10812+ size_t size = 4;
10813+
10814+ while (size && (result[size - 1] == '\0')) --size;
10815+
10816+ vresult = SWIG_FromCharPtrAndSize(result, size);
10817+ }
10818+ return vresult;
10819+fail:
10820+ return Qnil;
10821+}
10822+
10823+
10824+SWIGINTERN VALUE
10825+_wrap__mrcImageTailer_Rot1_set(int argc, VALUE *argv, VALUE self) {
10826+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10827+ mrcImageParaTypeReal arg2 ;
10828+ void *argp1 = 0 ;
10829+ int res1 = 0 ;
10830+ float val2 ;
10831+ int ecode2 = 0 ;
10832+
10833+ if ((argc < 1) || (argc > 1)) {
10834+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10835+ }
10836+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10837+ if (!SWIG_IsOK(res1)) {
10838+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Rot1", 1, self ));
10839+ }
10840+ arg1 = (_mrcImageTailer *)(argp1);
10841+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10842+ if (!SWIG_IsOK(ecode2)) {
10843+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Rot1", 2, argv[0] ));
10844+ }
10845+ arg2 = (mrcImageParaTypeReal)(val2);
10846+ if (arg1) (arg1)->Rot1 = arg2;
10847+ return Qnil;
10848+fail:
10849+ return Qnil;
10850+}
10851+
10852+
10853+SWIGINTERN VALUE
10854+_wrap__mrcImageTailer_Rot1_get(int argc, VALUE *argv, VALUE self) {
10855+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10856+ void *argp1 = 0 ;
10857+ int res1 = 0 ;
10858+ mrcImageParaTypeReal result;
10859+ VALUE vresult = Qnil;
10860+
10861+ if ((argc < 0) || (argc > 0)) {
10862+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10863+ }
10864+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10865+ if (!SWIG_IsOK(res1)) {
10866+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Rot1", 1, self ));
10867+ }
10868+ arg1 = (_mrcImageTailer *)(argp1);
10869+ result = (mrcImageParaTypeReal) ((arg1)->Rot1);
10870+ vresult = SWIG_From_float((float)(result));
10871+ return vresult;
10872+fail:
10873+ return Qnil;
10874+}
10875+
10876+
10877+SWIGINTERN VALUE
10878+_wrap__mrcImageTailer_Rot2_set(int argc, VALUE *argv, VALUE self) {
10879+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10880+ mrcImageParaTypeReal arg2 ;
10881+ void *argp1 = 0 ;
10882+ int res1 = 0 ;
10883+ float val2 ;
10884+ int ecode2 = 0 ;
10885+
10886+ if ((argc < 1) || (argc > 1)) {
10887+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10888+ }
10889+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10890+ if (!SWIG_IsOK(res1)) {
10891+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Rot2", 1, self ));
10892+ }
10893+ arg1 = (_mrcImageTailer *)(argp1);
10894+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10895+ if (!SWIG_IsOK(ecode2)) {
10896+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Rot2", 2, argv[0] ));
10897+ }
10898+ arg2 = (mrcImageParaTypeReal)(val2);
10899+ if (arg1) (arg1)->Rot2 = arg2;
10900+ return Qnil;
10901+fail:
10902+ return Qnil;
10903+}
10904+
10905+
10906+SWIGINTERN VALUE
10907+_wrap__mrcImageTailer_Rot2_get(int argc, VALUE *argv, VALUE self) {
10908+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10909+ void *argp1 = 0 ;
10910+ int res1 = 0 ;
10911+ mrcImageParaTypeReal result;
10912+ VALUE vresult = Qnil;
10913+
10914+ if ((argc < 0) || (argc > 0)) {
10915+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10916+ }
10917+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10918+ if (!SWIG_IsOK(res1)) {
10919+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Rot2", 1, self ));
10920+ }
10921+ arg1 = (_mrcImageTailer *)(argp1);
10922+ result = (mrcImageParaTypeReal) ((arg1)->Rot2);
10923+ vresult = SWIG_From_float((float)(result));
10924+ return vresult;
10925+fail:
10926+ return Qnil;
10927+}
10928+
10929+
10930+SWIGINTERN VALUE
10931+_wrap__mrcImageTailer_Rot3_set(int argc, VALUE *argv, VALUE self) {
10932+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10933+ mrcImageParaTypeReal arg2 ;
10934+ void *argp1 = 0 ;
10935+ int res1 = 0 ;
10936+ float val2 ;
10937+ int ecode2 = 0 ;
10938+
10939+ if ((argc < 1) || (argc > 1)) {
10940+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10941+ }
10942+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10943+ if (!SWIG_IsOK(res1)) {
10944+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Rot3", 1, self ));
10945+ }
10946+ arg1 = (_mrcImageTailer *)(argp1);
10947+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
10948+ if (!SWIG_IsOK(ecode2)) {
10949+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","Rot3", 2, argv[0] ));
10950+ }
10951+ arg2 = (mrcImageParaTypeReal)(val2);
10952+ if (arg1) (arg1)->Rot3 = arg2;
10953+ return Qnil;
10954+fail:
10955+ return Qnil;
10956+}
10957+
10958+
10959+SWIGINTERN VALUE
10960+_wrap__mrcImageTailer_Rot3_get(int argc, VALUE *argv, VALUE self) {
10961+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10962+ void *argp1 = 0 ;
10963+ int res1 = 0 ;
10964+ mrcImageParaTypeReal result;
10965+ VALUE vresult = Qnil;
10966+
10967+ if ((argc < 0) || (argc > 0)) {
10968+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
10969+ }
10970+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10971+ if (!SWIG_IsOK(res1)) {
10972+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Rot3", 1, self ));
10973+ }
10974+ arg1 = (_mrcImageTailer *)(argp1);
10975+ result = (mrcImageParaTypeReal) ((arg1)->Rot3);
10976+ vresult = SWIG_From_float((float)(result));
10977+ return vresult;
10978+fail:
10979+ return Qnil;
10980+}
10981+
10982+
10983+SWIGINTERN VALUE
10984+_wrap__mrcImageTailer_Mirror_set(int argc, VALUE *argv, VALUE self) {
10985+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
10986+ mrcImageParaTypeInteger arg2 ;
10987+ void *argp1 = 0 ;
10988+ int res1 = 0 ;
10989+ int val2 ;
10990+ int ecode2 = 0 ;
10991+
10992+ if ((argc < 1) || (argc > 1)) {
10993+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
10994+ }
10995+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
10996+ if (!SWIG_IsOK(res1)) {
10997+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Mirror", 1, self ));
10998+ }
10999+ arg1 = (_mrcImageTailer *)(argp1);
11000+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
11001+ if (!SWIG_IsOK(ecode2)) {
11002+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","Mirror", 2, argv[0] ));
11003+ }
11004+ arg2 = (mrcImageParaTypeInteger)(val2);
11005+ if (arg1) (arg1)->Mirror = arg2;
11006+ return Qnil;
11007+fail:
11008+ return Qnil;
11009+}
11010+
11011+
11012+SWIGINTERN VALUE
11013+_wrap__mrcImageTailer_Mirror_get(int argc, VALUE *argv, VALUE self) {
11014+ _mrcImageTailer *arg1 = (_mrcImageTailer *) 0 ;
11015+ void *argp1 = 0 ;
11016+ int res1 = 0 ;
11017+ mrcImageParaTypeInteger result;
11018+ VALUE vresult = Qnil;
11019+
11020+ if ((argc < 0) || (argc > 0)) {
11021+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11022+ }
11023+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
11024+ if (!SWIG_IsOK(res1)) {
11025+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "_mrcImageTailer *","Mirror", 1, self ));
11026+ }
11027+ arg1 = (_mrcImageTailer *)(argp1);
11028+ result = (mrcImageParaTypeInteger) ((arg1)->Mirror);
11029+ vresult = SWIG_From_int((int)(result));
11030+ return vresult;
11031+fail:
11032+ return Qnil;
11033+}
11034+
11035+
11036+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
11037+SWIGINTERN VALUE
11038+_wrap__mrcImageTailer_allocate(VALUE self) {
11039+#else
11040+ SWIGINTERN VALUE
11041+ _wrap__mrcImageTailer_allocate(int argc, VALUE *argv, VALUE self) {
11042+#endif
11043+
11044+
11045+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p__mrcImageTailer);
11046+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
11047+ rb_obj_call_init(vresult, argc, argv);
11048+#endif
11049+ return vresult;
11050+ }
11051+
11052+
11053+SWIGINTERN VALUE
11054+_wrap_new__mrcImageTailer(int argc, VALUE *argv, VALUE self) {
11055+ _mrcImageTailer *result = 0 ;
11056+
11057+ if ((argc < 0) || (argc > 0)) {
11058+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11059+ }
11060+ result = (_mrcImageTailer *)calloc(1, sizeof(_mrcImageTailer));
11061+ DATA_PTR(self) = result;
11062+ return self;
11063+fail:
11064+ return Qnil;
11065+}
11066+
11067+
11068+SWIGINTERN void
11069+free__mrcImageTailer(_mrcImageTailer *arg1) {
11070+ free((char *) arg1);
11071+}
11072+
11073+swig_class SwigClassMrcImageTailer;
11074+
11075+SWIGINTERN VALUE
11076+_wrap_mrcImageTailer_All_set(int argc, VALUE *argv, VALUE self) {
11077+ mrcImageTailer *arg1 = (mrcImageTailer *) 0 ;
11078+ unsigned char *arg2 ;
11079+ void *argp1 = 0 ;
11080+ int res1 = 0 ;
11081+ void *argp2 = 0 ;
11082+ int res2 = 0 ;
11083+
11084+ if ((argc < 1) || (argc > 1)) {
11085+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11086+ }
11087+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageTailer, 0 | 0 );
11088+ if (!SWIG_IsOK(res1)) {
11089+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageTailer *","All", 1, self ));
11090+ }
11091+ arg1 = (mrcImageTailer *)(argp1);
11092+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 | 0 );
11093+ if (!SWIG_IsOK(res2)) {
11094+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char [(1024)]","All", 2, argv[0] ));
11095+ }
11096+ arg2 = (unsigned char *)(argp2);
11097+ {
11098+ if (arg2) {
11099+ size_t ii = 0;
11100+ for (; ii < (size_t)(1024); ++ii) arg1->All[ii] = arg2[ii];
11101+ } else {
11102+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""All""' of type '""unsigned char [(1024)]""'");
11103+ }
11104+ }
11105+ return Qnil;
11106+fail:
11107+ return Qnil;
11108+}
11109+
11110+
11111+SWIGINTERN VALUE
11112+_wrap_mrcImageTailer_All_get(int argc, VALUE *argv, VALUE self) {
11113+ mrcImageTailer *arg1 = (mrcImageTailer *) 0 ;
11114+ void *argp1 = 0 ;
11115+ int res1 = 0 ;
11116+ unsigned char *result = 0 ;
11117+ VALUE vresult = Qnil;
11118+
11119+ if ((argc < 0) || (argc > 0)) {
11120+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11121+ }
11122+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageTailer, 0 | 0 );
11123+ if (!SWIG_IsOK(res1)) {
11124+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageTailer *","All", 1, self ));
11125+ }
11126+ arg1 = (mrcImageTailer *)(argp1);
11127+ result = (unsigned char *)(unsigned char *) ((arg1)->All);
11128+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
11129+ return vresult;
11130+fail:
11131+ return Qnil;
11132+}
11133+
11134+
11135+SWIGINTERN VALUE
11136+_wrap_mrcImageTailer_Int_set(int argc, VALUE *argv, VALUE self) {
11137+ mrcImageTailer *arg1 = (mrcImageTailer *) 0 ;
11138+ mrcImageParaTypeInteger *arg2 ;
11139+ void *argp1 = 0 ;
11140+ int res1 = 0 ;
11141+ void *argp2 = 0 ;
11142+ int res2 = 0 ;
11143+
11144+ if ((argc < 1) || (argc > 1)) {
11145+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11146+ }
11147+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageTailer, 0 | 0 );
11148+ if (!SWIG_IsOK(res1)) {
11149+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageTailer *","Int", 1, self ));
11150+ }
11151+ arg1 = (mrcImageTailer *)(argp1);
11152+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_int, 0 | 0 );
11153+ if (!SWIG_IsOK(res2)) {
11154+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger [(1024)/4]","Int", 2, argv[0] ));
11155+ }
11156+ arg2 = (mrcImageParaTypeInteger *)(argp2);
11157+ {
11158+ if (arg2) {
11159+ size_t ii = 0;
11160+ for (; ii < (size_t)(1024)/4; ++ii) arg1->Int[ii] = arg2[ii];
11161+ } else {
11162+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Int""' of type '""mrcImageParaTypeInteger [(1024)/4]""'");
11163+ }
11164+ }
11165+ return Qnil;
11166+fail:
11167+ return Qnil;
11168+}
11169+
11170+
11171+SWIGINTERN VALUE
11172+_wrap_mrcImageTailer_Int_get(int argc, VALUE *argv, VALUE self) {
11173+ mrcImageTailer *arg1 = (mrcImageTailer *) 0 ;
11174+ void *argp1 = 0 ;
11175+ int res1 = 0 ;
11176+ mrcImageParaTypeInteger *result = 0 ;
11177+ VALUE vresult = Qnil;
11178+
11179+ if ((argc < 0) || (argc > 0)) {
11180+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11181+ }
11182+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageTailer, 0 | 0 );
11183+ if (!SWIG_IsOK(res1)) {
11184+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageTailer *","Int", 1, self ));
11185+ }
11186+ arg1 = (mrcImageTailer *)(argp1);
11187+ result = (mrcImageParaTypeInteger *)(mrcImageParaTypeInteger *) ((arg1)->Int);
11188+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
11189+ return vresult;
11190+fail:
11191+ return Qnil;
11192+}
11193+
11194+
11195+SWIGINTERN VALUE
11196+_wrap_mrcImageTailer_Real_set(int argc, VALUE *argv, VALUE self) {
11197+ mrcImageTailer *arg1 = (mrcImageTailer *) 0 ;
11198+ mrcImageParaTypeReal *arg2 ;
11199+ void *argp1 = 0 ;
11200+ int res1 = 0 ;
11201+ void *argp2 = 0 ;
11202+ int res2 = 0 ;
11203+
11204+ if ((argc < 1) || (argc > 1)) {
11205+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11206+ }
11207+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageTailer, 0 | 0 );
11208+ if (!SWIG_IsOK(res1)) {
11209+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageTailer *","Real", 1, self ));
11210+ }
11211+ arg1 = (mrcImageTailer *)(argp1);
11212+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 | 0 );
11213+ if (!SWIG_IsOK(res2)) {
11214+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal [(1024)/4]","Real", 2, argv[0] ));
11215+ }
11216+ arg2 = (mrcImageParaTypeReal *)(argp2);
11217+ {
11218+ if (arg2) {
11219+ size_t ii = 0;
11220+ for (; ii < (size_t)(1024)/4; ++ii) arg1->Real[ii] = arg2[ii];
11221+ } else {
11222+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Real""' of type '""mrcImageParaTypeReal [(1024)/4]""'");
11223+ }
11224+ }
11225+ return Qnil;
11226+fail:
11227+ return Qnil;
11228+}
11229+
11230+
11231+SWIGINTERN VALUE
11232+_wrap_mrcImageTailer_Real_get(int argc, VALUE *argv, VALUE self) {
11233+ mrcImageTailer *arg1 = (mrcImageTailer *) 0 ;
11234+ void *argp1 = 0 ;
11235+ int res1 = 0 ;
11236+ mrcImageParaTypeReal *result = 0 ;
11237+ VALUE vresult = Qnil;
11238+
11239+ if ((argc < 0) || (argc > 0)) {
11240+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11241+ }
11242+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageTailer, 0 | 0 );
11243+ if (!SWIG_IsOK(res1)) {
11244+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageTailer *","Real", 1, self ));
11245+ }
11246+ arg1 = (mrcImageTailer *)(argp1);
11247+ result = (mrcImageParaTypeReal *)(mrcImageParaTypeReal *) ((arg1)->Real);
11248+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
11249+ return vresult;
11250+fail:
11251+ return Qnil;
11252+}
11253+
11254+
11255+SWIGINTERN VALUE
11256+_wrap_mrcImageTailer_Cont_set(int argc, VALUE *argv, VALUE self) {
11257+ mrcImageTailer *arg1 = (mrcImageTailer *) 0 ;
11258+ _mrcImageTailer *arg2 = (_mrcImageTailer *) 0 ;
11259+ void *argp1 = 0 ;
11260+ int res1 = 0 ;
11261+ void *argp2 = 0 ;
11262+ int res2 = 0 ;
11263+
11264+ if ((argc < 1) || (argc > 1)) {
11265+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11266+ }
11267+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageTailer, 0 | 0 );
11268+ if (!SWIG_IsOK(res1)) {
11269+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageTailer *","Cont", 1, self ));
11270+ }
11271+ arg1 = (mrcImageTailer *)(argp1);
11272+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p__mrcImageTailer, 0 | 0 );
11273+ if (!SWIG_IsOK(res2)) {
11274+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "_mrcImageTailer *","Cont", 2, argv[0] ));
11275+ }
11276+ arg2 = (_mrcImageTailer *)(argp2);
11277+ if (arg1) (arg1)->Cont = *arg2;
11278+ return Qnil;
11279+fail:
11280+ return Qnil;
11281+}
11282+
11283+
11284+SWIGINTERN VALUE
11285+_wrap_mrcImageTailer_Cont_get(int argc, VALUE *argv, VALUE self) {
11286+ mrcImageTailer *arg1 = (mrcImageTailer *) 0 ;
11287+ void *argp1 = 0 ;
11288+ int res1 = 0 ;
11289+ _mrcImageTailer *result = 0 ;
11290+ VALUE vresult = Qnil;
11291+
11292+ if ((argc < 0) || (argc > 0)) {
11293+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11294+ }
11295+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageTailer, 0 | 0 );
11296+ if (!SWIG_IsOK(res1)) {
11297+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageTailer *","Cont", 1, self ));
11298+ }
11299+ arg1 = (mrcImageTailer *)(argp1);
11300+ result = (_mrcImageTailer *)& ((arg1)->Cont);
11301+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__mrcImageTailer, 0 | 0 );
11302+ return vresult;
11303+fail:
11304+ return Qnil;
11305+}
11306+
11307+
11308+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
11309+SWIGINTERN VALUE
11310+_wrap_mrcImageTailer_allocate(VALUE self) {
11311+#else
11312+ SWIGINTERN VALUE
11313+ _wrap_mrcImageTailer_allocate(int argc, VALUE *argv, VALUE self) {
11314+#endif
11315+
11316+
11317+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_mrcImageTailer);
11318+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
11319+ rb_obj_call_init(vresult, argc, argv);
11320+#endif
11321+ return vresult;
11322+ }
11323+
11324+
11325+SWIGINTERN VALUE
11326+_wrap_new_mrcImageTailer(int argc, VALUE *argv, VALUE self) {
11327+ mrcImageTailer *result = 0 ;
11328+
11329+ if ((argc < 0) || (argc > 0)) {
11330+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11331+ }
11332+ result = (mrcImageTailer *)calloc(1, sizeof(mrcImageTailer));
11333+ DATA_PTR(self) = result;
11334+ return self;
11335+fail:
11336+ return Qnil;
11337+}
11338+
11339+
11340+SWIGINTERN void
11341+free_mrcImageTailer(mrcImageTailer *arg1) {
11342+ free((char *) arg1);
11343+}
11344+
11345+swig_class SwigClassMrcImage;
11346+
11347+SWIGINTERN VALUE
11348+_wrap_mrcImage_Header_set(int argc, VALUE *argv, VALUE self) {
11349+ mrcImage *arg1 = (mrcImage *) 0 ;
11350+ mrcImageHeader *arg2 = (mrcImageHeader *) 0 ;
11351+ void *argp1 = 0 ;
11352+ int res1 = 0 ;
11353+ void *argp2 = 0 ;
11354+ int res2 = 0 ;
11355+
11356+ if ((argc < 1) || (argc > 1)) {
11357+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11358+ }
11359+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11360+ if (!SWIG_IsOK(res1)) {
11361+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","Header", 1, self ));
11362+ }
11363+ arg1 = (mrcImage *)(argp1);
11364+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageHeader, 0 | 0 );
11365+ if (!SWIG_IsOK(res2)) {
11366+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageHeader *","Header", 2, argv[0] ));
11367+ }
11368+ arg2 = (mrcImageHeader *)(argp2);
11369+ if (arg1) (arg1)->Header = *arg2;
11370+ return Qnil;
11371+fail:
11372+ return Qnil;
11373+}
11374+
11375+
11376+SWIGINTERN VALUE
11377+_wrap_mrcImage_Header_get(int argc, VALUE *argv, VALUE self) {
11378+ mrcImage *arg1 = (mrcImage *) 0 ;
11379+ void *argp1 = 0 ;
11380+ int res1 = 0 ;
11381+ mrcImageHeader *result = 0 ;
11382+ VALUE vresult = Qnil;
11383+
11384+ if ((argc < 0) || (argc > 0)) {
11385+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11386+ }
11387+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11388+ if (!SWIG_IsOK(res1)) {
11389+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","Header", 1, self ));
11390+ }
11391+ arg1 = (mrcImage *)(argp1);
11392+ result = (mrcImageHeader *)& ((arg1)->Header);
11393+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageHeader, 0 | 0 );
11394+ return vresult;
11395+fail:
11396+ return Qnil;
11397+}
11398+
11399+
11400+SWIGINTERN VALUE
11401+_wrap_mrcImage_BytePerImage_set(int argc, VALUE *argv, VALUE self) {
11402+ mrcImage *arg1 = (mrcImage *) 0 ;
11403+ size_t arg2 ;
11404+ void *argp1 = 0 ;
11405+ int res1 = 0 ;
11406+ size_t val2 ;
11407+ int ecode2 = 0 ;
11408+
11409+ if ((argc < 1) || (argc > 1)) {
11410+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11411+ }
11412+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11413+ if (!SWIG_IsOK(res1)) {
11414+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","BytePerImage", 1, self ));
11415+ }
11416+ arg1 = (mrcImage *)(argp1);
11417+ ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
11418+ if (!SWIG_IsOK(ecode2)) {
11419+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","BytePerImage", 2, argv[0] ));
11420+ }
11421+ arg2 = (size_t)(val2);
11422+ if (arg1) (arg1)->BytePerImage = arg2;
11423+ return Qnil;
11424+fail:
11425+ return Qnil;
11426+}
11427+
11428+
11429+SWIGINTERN VALUE
11430+_wrap_mrcImage_BytePerImage_get(int argc, VALUE *argv, VALUE self) {
11431+ mrcImage *arg1 = (mrcImage *) 0 ;
11432+ void *argp1 = 0 ;
11433+ int res1 = 0 ;
11434+ size_t result;
11435+ VALUE vresult = Qnil;
11436+
11437+ if ((argc < 0) || (argc > 0)) {
11438+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11439+ }
11440+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11441+ if (!SWIG_IsOK(res1)) {
11442+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","BytePerImage", 1, self ));
11443+ }
11444+ arg1 = (mrcImage *)(argp1);
11445+ result = ((arg1)->BytePerImage);
11446+ vresult = SWIG_From_size_t((size_t)(result));
11447+ return vresult;
11448+fail:
11449+ return Qnil;
11450+}
11451+
11452+
11453+SWIGINTERN VALUE
11454+_wrap_mrcImage_BytePerBand_set(int argc, VALUE *argv, VALUE self) {
11455+ mrcImage *arg1 = (mrcImage *) 0 ;
11456+ mrcImageParaTypeInteger arg2 ;
11457+ void *argp1 = 0 ;
11458+ int res1 = 0 ;
11459+ int val2 ;
11460+ int ecode2 = 0 ;
11461+
11462+ if ((argc < 1) || (argc > 1)) {
11463+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11464+ }
11465+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11466+ if (!SWIG_IsOK(res1)) {
11467+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","BytePerBand", 1, self ));
11468+ }
11469+ arg1 = (mrcImage *)(argp1);
11470+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
11471+ if (!SWIG_IsOK(ecode2)) {
11472+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","BytePerBand", 2, argv[0] ));
11473+ }
11474+ arg2 = (mrcImageParaTypeInteger)(val2);
11475+ if (arg1) (arg1)->BytePerBand = arg2;
11476+ return Qnil;
11477+fail:
11478+ return Qnil;
11479+}
11480+
11481+
11482+SWIGINTERN VALUE
11483+_wrap_mrcImage_BytePerBand_get(int argc, VALUE *argv, VALUE self) {
11484+ mrcImage *arg1 = (mrcImage *) 0 ;
11485+ void *argp1 = 0 ;
11486+ int res1 = 0 ;
11487+ mrcImageParaTypeInteger result;
11488+ VALUE vresult = Qnil;
11489+
11490+ if ((argc < 0) || (argc > 0)) {
11491+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11492+ }
11493+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11494+ if (!SWIG_IsOK(res1)) {
11495+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","BytePerBand", 1, self ));
11496+ }
11497+ arg1 = (mrcImage *)(argp1);
11498+ result = (mrcImageParaTypeInteger) ((arg1)->BytePerBand);
11499+ vresult = SWIG_From_int((int)(result));
11500+ return vresult;
11501+fail:
11502+ return Qnil;
11503+}
11504+
11505+
11506+SWIGINTERN VALUE
11507+_wrap_mrcImage_BandPerPixel_set(int argc, VALUE *argv, VALUE self) {
11508+ mrcImage *arg1 = (mrcImage *) 0 ;
11509+ mrcImageParaTypeInteger arg2 ;
11510+ void *argp1 = 0 ;
11511+ int res1 = 0 ;
11512+ int val2 ;
11513+ int ecode2 = 0 ;
11514+
11515+ if ((argc < 1) || (argc > 1)) {
11516+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11517+ }
11518+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11519+ if (!SWIG_IsOK(res1)) {
11520+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","BandPerPixel", 1, self ));
11521+ }
11522+ arg1 = (mrcImage *)(argp1);
11523+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
11524+ if (!SWIG_IsOK(ecode2)) {
11525+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","BandPerPixel", 2, argv[0] ));
11526+ }
11527+ arg2 = (mrcImageParaTypeInteger)(val2);
11528+ if (arg1) (arg1)->BandPerPixel = arg2;
11529+ return Qnil;
11530+fail:
11531+ return Qnil;
11532+}
11533+
11534+
11535+SWIGINTERN VALUE
11536+_wrap_mrcImage_BandPerPixel_get(int argc, VALUE *argv, VALUE self) {
11537+ mrcImage *arg1 = (mrcImage *) 0 ;
11538+ void *argp1 = 0 ;
11539+ int res1 = 0 ;
11540+ mrcImageParaTypeInteger result;
11541+ VALUE vresult = Qnil;
11542+
11543+ if ((argc < 0) || (argc > 0)) {
11544+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11545+ }
11546+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11547+ if (!SWIG_IsOK(res1)) {
11548+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","BandPerPixel", 1, self ));
11549+ }
11550+ arg1 = (mrcImage *)(argp1);
11551+ result = (mrcImageParaTypeInteger) ((arg1)->BandPerPixel);
11552+ vresult = SWIG_From_int((int)(result));
11553+ return vresult;
11554+fail:
11555+ return Qnil;
11556+}
11557+
11558+
11559+SWIGINTERN VALUE
11560+_wrap_mrcImage_PixelPerImage_set(int argc, VALUE *argv, VALUE self) {
11561+ mrcImage *arg1 = (mrcImage *) 0 ;
11562+ size_t arg2 ;
11563+ void *argp1 = 0 ;
11564+ int res1 = 0 ;
11565+ size_t val2 ;
11566+ int ecode2 = 0 ;
11567+
11568+ if ((argc < 1) || (argc > 1)) {
11569+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11570+ }
11571+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11572+ if (!SWIG_IsOK(res1)) {
11573+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","PixelPerImage", 1, self ));
11574+ }
11575+ arg1 = (mrcImage *)(argp1);
11576+ ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
11577+ if (!SWIG_IsOK(ecode2)) {
11578+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","PixelPerImage", 2, argv[0] ));
11579+ }
11580+ arg2 = (size_t)(val2);
11581+ if (arg1) (arg1)->PixelPerImage = arg2;
11582+ return Qnil;
11583+fail:
11584+ return Qnil;
11585+}
11586+
11587+
11588+SWIGINTERN VALUE
11589+_wrap_mrcImage_PixelPerImage_get(int argc, VALUE *argv, VALUE self) {
11590+ mrcImage *arg1 = (mrcImage *) 0 ;
11591+ void *argp1 = 0 ;
11592+ int res1 = 0 ;
11593+ size_t result;
11594+ VALUE vresult = Qnil;
11595+
11596+ if ((argc < 0) || (argc > 0)) {
11597+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11598+ }
11599+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11600+ if (!SWIG_IsOK(res1)) {
11601+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","PixelPerImage", 1, self ));
11602+ }
11603+ arg1 = (mrcImage *)(argp1);
11604+ result = ((arg1)->PixelPerImage);
11605+ vresult = SWIG_From_size_t((size_t)(result));
11606+ return vresult;
11607+fail:
11608+ return Qnil;
11609+}
11610+
11611+
11612+SWIGINTERN VALUE
11613+_wrap_mrcImage_status_set(int argc, VALUE *argv, VALUE self) {
11614+ mrcImage *arg1 = (mrcImage *) 0 ;
11615+ mrcStatusType arg2 ;
11616+ void *argp1 = 0 ;
11617+ int res1 = 0 ;
11618+ unsigned int val2 ;
11619+ int ecode2 = 0 ;
11620+
11621+ if ((argc < 1) || (argc > 1)) {
11622+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11623+ }
11624+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11625+ if (!SWIG_IsOK(res1)) {
11626+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","status", 1, self ));
11627+ }
11628+ arg1 = (mrcImage *)(argp1);
11629+ ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
11630+ if (!SWIG_IsOK(ecode2)) {
11631+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcStatusType","status", 2, argv[0] ));
11632+ }
11633+ arg2 = (mrcStatusType)(val2);
11634+ if (arg1) (arg1)->status = arg2;
11635+ return Qnil;
11636+fail:
11637+ return Qnil;
11638+}
11639+
11640+
11641+SWIGINTERN VALUE
11642+_wrap_mrcImage_status_get(int argc, VALUE *argv, VALUE self) {
11643+ mrcImage *arg1 = (mrcImage *) 0 ;
11644+ void *argp1 = 0 ;
11645+ int res1 = 0 ;
11646+ mrcStatusType result;
11647+ VALUE vresult = Qnil;
11648+
11649+ if ((argc < 0) || (argc > 0)) {
11650+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11651+ }
11652+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11653+ if (!SWIG_IsOK(res1)) {
11654+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","status", 1, self ));
11655+ }
11656+ arg1 = (mrcImage *)(argp1);
11657+ result = (mrcStatusType) ((arg1)->status);
11658+ vresult = SWIG_From_unsigned_SS_int((unsigned int)(result));
11659+ return vresult;
11660+fail:
11661+ return Qnil;
11662+}
11663+
11664+
11665+SWIGINTERN VALUE
11666+_wrap_mrcImage_Image_set(int argc, VALUE *argv, VALUE self) {
11667+ mrcImage *arg1 = (mrcImage *) 0 ;
11668+ char *arg2 = (char *) 0 ;
11669+ void *argp1 = 0 ;
11670+ int res1 = 0 ;
11671+ int res2 ;
11672+ char *buf2 = 0 ;
11673+ int alloc2 = 0 ;
11674+
11675+ if ((argc < 1) || (argc > 1)) {
11676+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11677+ }
11678+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11679+ if (!SWIG_IsOK(res1)) {
11680+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","Image", 1, self ));
11681+ }
11682+ arg1 = (mrcImage *)(argp1);
11683+ res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
11684+ if (!SWIG_IsOK(res2)) {
11685+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","Image", 2, argv[0] ));
11686+ }
11687+ arg2 = (char *)(buf2);
11688+ if (arg1->Image) free((char*)arg1->Image);
11689+ if (arg2) {
11690+ size_t size = strlen((const char *)(arg2)) + 1;
11691+ arg1->Image = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
11692+ } else {
11693+ arg1->Image = 0;
11694+ }
11695+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11696+ return Qnil;
11697+fail:
11698+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11699+ return Qnil;
11700+}
11701+
11702+
11703+SWIGINTERN VALUE
11704+_wrap_mrcImage_Image_get(int argc, VALUE *argv, VALUE self) {
11705+ mrcImage *arg1 = (mrcImage *) 0 ;
11706+ void *argp1 = 0 ;
11707+ int res1 = 0 ;
11708+ char *result = 0 ;
11709+ VALUE vresult = Qnil;
11710+
11711+ if ((argc < 0) || (argc > 0)) {
11712+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11713+ }
11714+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11715+ if (!SWIG_IsOK(res1)) {
11716+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","Image", 1, self ));
11717+ }
11718+ arg1 = (mrcImage *)(argp1);
11719+ result = (char *) ((arg1)->Image);
11720+ vresult = SWIG_FromCharPtr((const char *)result);
11721+ return vresult;
11722+fail:
11723+ return Qnil;
11724+}
11725+
11726+
11727+SWIGINTERN VALUE
11728+_wrap_mrcImage_ImageCharImage_set(int argc, VALUE *argv, VALUE self) {
11729+ mrcImage *arg1 = (mrcImage *) 0 ;
11730+ unsigned char *arg2 = (unsigned char *) 0 ;
11731+ void *argp1 = 0 ;
11732+ int res1 = 0 ;
11733+ void *argp2 = 0 ;
11734+ int res2 = 0 ;
11735+
11736+ if ((argc < 1) || (argc > 1)) {
11737+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11738+ }
11739+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11740+ if (!SWIG_IsOK(res1)) {
11741+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageCharImage", 1, self ));
11742+ }
11743+ arg1 = (mrcImage *)(argp1);
11744+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, SWIG_POINTER_DISOWN | 0 );
11745+ if (!SWIG_IsOK(res2)) {
11746+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char *","ImageCharImage", 2, argv[0] ));
11747+ }
11748+ arg2 = (unsigned char *)(argp2);
11749+ if (arg1) (arg1)->ImageCharImage = arg2;
11750+ return Qnil;
11751+fail:
11752+ return Qnil;
11753+}
11754+
11755+
11756+SWIGINTERN VALUE
11757+_wrap_mrcImage_ImageCharImage_get(int argc, VALUE *argv, VALUE self) {
11758+ mrcImage *arg1 = (mrcImage *) 0 ;
11759+ void *argp1 = 0 ;
11760+ int res1 = 0 ;
11761+ unsigned char *result = 0 ;
11762+ VALUE vresult = Qnil;
11763+
11764+ if ((argc < 0) || (argc > 0)) {
11765+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11766+ }
11767+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11768+ if (!SWIG_IsOK(res1)) {
11769+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageCharImage", 1, self ));
11770+ }
11771+ arg1 = (mrcImage *)(argp1);
11772+ result = (unsigned char *) ((arg1)->ImageCharImage);
11773+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 | 0 );
11774+ return vresult;
11775+fail:
11776+ return Qnil;
11777+}
11778+
11779+
11780+SWIGINTERN VALUE
11781+_wrap_mrcImage_ImageShortImage_set(int argc, VALUE *argv, VALUE self) {
11782+ mrcImage *arg1 = (mrcImage *) 0 ;
11783+ unsigned short *arg2 = (unsigned short *) 0 ;
11784+ void *argp1 = 0 ;
11785+ int res1 = 0 ;
11786+ void *argp2 = 0 ;
11787+ int res2 = 0 ;
11788+
11789+ if ((argc < 1) || (argc > 1)) {
11790+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11791+ }
11792+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11793+ if (!SWIG_IsOK(res1)) {
11794+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageShortImage", 1, self ));
11795+ }
11796+ arg1 = (mrcImage *)(argp1);
11797+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, SWIG_POINTER_DISOWN | 0 );
11798+ if (!SWIG_IsOK(res2)) {
11799+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned short *","ImageShortImage", 2, argv[0] ));
11800+ }
11801+ arg2 = (unsigned short *)(argp2);
11802+ if (arg1) (arg1)->ImageShortImage = arg2;
11803+ return Qnil;
11804+fail:
11805+ return Qnil;
11806+}
11807+
11808+
11809+SWIGINTERN VALUE
11810+_wrap_mrcImage_ImageShortImage_get(int argc, VALUE *argv, VALUE self) {
11811+ mrcImage *arg1 = (mrcImage *) 0 ;
11812+ void *argp1 = 0 ;
11813+ int res1 = 0 ;
11814+ unsigned short *result = 0 ;
11815+ VALUE vresult = Qnil;
11816+
11817+ if ((argc < 0) || (argc > 0)) {
11818+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11819+ }
11820+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11821+ if (!SWIG_IsOK(res1)) {
11822+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageShortImage", 1, self ));
11823+ }
11824+ arg1 = (mrcImage *)(argp1);
11825+ result = (unsigned short *) ((arg1)->ImageShortImage);
11826+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 | 0 );
11827+ return vresult;
11828+fail:
11829+ return Qnil;
11830+}
11831+
11832+
11833+SWIGINTERN VALUE
11834+_wrap_mrcImage_ImageLongImage_set(int argc, VALUE *argv, VALUE self) {
11835+ mrcImage *arg1 = (mrcImage *) 0 ;
11836+ unsigned long *arg2 = (unsigned long *) 0 ;
11837+ void *argp1 = 0 ;
11838+ int res1 = 0 ;
11839+ void *argp2 = 0 ;
11840+ int res2 = 0 ;
11841+
11842+ if ((argc < 1) || (argc > 1)) {
11843+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11844+ }
11845+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11846+ if (!SWIG_IsOK(res1)) {
11847+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageLongImage", 1, self ));
11848+ }
11849+ arg1 = (mrcImage *)(argp1);
11850+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_long, SWIG_POINTER_DISOWN | 0 );
11851+ if (!SWIG_IsOK(res2)) {
11852+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned long *","ImageLongImage", 2, argv[0] ));
11853+ }
11854+ arg2 = (unsigned long *)(argp2);
11855+ if (arg1) (arg1)->ImageLongImage = arg2;
11856+ return Qnil;
11857+fail:
11858+ return Qnil;
11859+}
11860+
11861+
11862+SWIGINTERN VALUE
11863+_wrap_mrcImage_ImageLongImage_get(int argc, VALUE *argv, VALUE self) {
11864+ mrcImage *arg1 = (mrcImage *) 0 ;
11865+ void *argp1 = 0 ;
11866+ int res1 = 0 ;
11867+ unsigned long *result = 0 ;
11868+ VALUE vresult = Qnil;
11869+
11870+ if ((argc < 0) || (argc > 0)) {
11871+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11872+ }
11873+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11874+ if (!SWIG_IsOK(res1)) {
11875+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageLongImage", 1, self ));
11876+ }
11877+ arg1 = (mrcImage *)(argp1);
11878+ result = (unsigned long *) ((arg1)->ImageLongImage);
11879+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_long, 0 | 0 );
11880+ return vresult;
11881+fail:
11882+ return Qnil;
11883+}
11884+
11885+
11886+SWIGINTERN VALUE
11887+_wrap_mrcImage_ImageFloatImage_set(int argc, VALUE *argv, VALUE self) {
11888+ mrcImage *arg1 = (mrcImage *) 0 ;
11889+ float *arg2 = (float *) 0 ;
11890+ void *argp1 = 0 ;
11891+ int res1 = 0 ;
11892+ void *argp2 = 0 ;
11893+ int res2 = 0 ;
11894+
11895+ if ((argc < 1) || (argc > 1)) {
11896+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11897+ }
11898+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11899+ if (!SWIG_IsOK(res1)) {
11900+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageFloatImage", 1, self ));
11901+ }
11902+ arg1 = (mrcImage *)(argp1);
11903+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, SWIG_POINTER_DISOWN | 0 );
11904+ if (!SWIG_IsOK(res2)) {
11905+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float *","ImageFloatImage", 2, argv[0] ));
11906+ }
11907+ arg2 = (float *)(argp2);
11908+ if (arg1) (arg1)->ImageFloatImage = arg2;
11909+ return Qnil;
11910+fail:
11911+ return Qnil;
11912+}
11913+
11914+
11915+SWIGINTERN VALUE
11916+_wrap_mrcImage_ImageFloatImage_get(int argc, VALUE *argv, VALUE self) {
11917+ mrcImage *arg1 = (mrcImage *) 0 ;
11918+ void *argp1 = 0 ;
11919+ int res1 = 0 ;
11920+ float *result = 0 ;
11921+ VALUE vresult = Qnil;
11922+
11923+ if ((argc < 0) || (argc > 0)) {
11924+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11925+ }
11926+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11927+ if (!SWIG_IsOK(res1)) {
11928+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageFloatImage", 1, self ));
11929+ }
11930+ arg1 = (mrcImage *)(argp1);
11931+ result = (float *) ((arg1)->ImageFloatImage);
11932+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 | 0 );
11933+ return vresult;
11934+fail:
11935+ return Qnil;
11936+}
11937+
11938+
11939+SWIGINTERN VALUE
11940+_wrap_mrcImage_ImageDoubleImage_set(int argc, VALUE *argv, VALUE self) {
11941+ mrcImage *arg1 = (mrcImage *) 0 ;
11942+ double *arg2 = (double *) 0 ;
11943+ void *argp1 = 0 ;
11944+ int res1 = 0 ;
11945+ void *argp2 = 0 ;
11946+ int res2 = 0 ;
11947+
11948+ if ((argc < 1) || (argc > 1)) {
11949+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
11950+ }
11951+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11952+ if (!SWIG_IsOK(res1)) {
11953+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageDoubleImage", 1, self ));
11954+ }
11955+ arg1 = (mrcImage *)(argp1);
11956+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_double, SWIG_POINTER_DISOWN | 0 );
11957+ if (!SWIG_IsOK(res2)) {
11958+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "double *","ImageDoubleImage", 2, argv[0] ));
11959+ }
11960+ arg2 = (double *)(argp2);
11961+ if (arg1) (arg1)->ImageDoubleImage = arg2;
11962+ return Qnil;
11963+fail:
11964+ return Qnil;
11965+}
11966+
11967+
11968+SWIGINTERN VALUE
11969+_wrap_mrcImage_ImageDoubleImage_get(int argc, VALUE *argv, VALUE self) {
11970+ mrcImage *arg1 = (mrcImage *) 0 ;
11971+ void *argp1 = 0 ;
11972+ int res1 = 0 ;
11973+ double *result = 0 ;
11974+ VALUE vresult = Qnil;
11975+
11976+ if ((argc < 0) || (argc > 0)) {
11977+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
11978+ }
11979+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
11980+ if (!SWIG_IsOK(res1)) {
11981+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageDoubleImage", 1, self ));
11982+ }
11983+ arg1 = (mrcImage *)(argp1);
11984+ result = (double *) ((arg1)->ImageDoubleImage);
11985+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_double, 0 | 0 );
11986+ return vresult;
11987+fail:
11988+ return Qnil;
11989+}
11990+
11991+
11992+SWIGINTERN VALUE
11993+_wrap_mrcImage_Tailer_set(int argc, VALUE *argv, VALUE self) {
11994+ mrcImage *arg1 = (mrcImage *) 0 ;
11995+ mrcImageTailer *arg2 = (mrcImageTailer *) 0 ;
11996+ void *argp1 = 0 ;
11997+ int res1 = 0 ;
11998+ void *argp2 = 0 ;
11999+ int res2 = 0 ;
12000+
12001+ if ((argc < 1) || (argc > 1)) {
12002+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12003+ }
12004+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12005+ if (!SWIG_IsOK(res1)) {
12006+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","Tailer", 1, self ));
12007+ }
12008+ arg1 = (mrcImage *)(argp1);
12009+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageTailer, SWIG_POINTER_DISOWN | 0 );
12010+ if (!SWIG_IsOK(res2)) {
12011+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageTailer *","Tailer", 2, argv[0] ));
12012+ }
12013+ arg2 = (mrcImageTailer *)(argp2);
12014+ if (arg1) (arg1)->Tailer = arg2;
12015+ return Qnil;
12016+fail:
12017+ return Qnil;
12018+}
12019+
12020+
12021+SWIGINTERN VALUE
12022+_wrap_mrcImage_Tailer_get(int argc, VALUE *argv, VALUE self) {
12023+ mrcImage *arg1 = (mrcImage *) 0 ;
12024+ void *argp1 = 0 ;
12025+ int res1 = 0 ;
12026+ mrcImageTailer *result = 0 ;
12027+ VALUE vresult = Qnil;
12028+
12029+ if ((argc < 0) || (argc > 0)) {
12030+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12031+ }
12032+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12033+ if (!SWIG_IsOK(res1)) {
12034+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","Tailer", 1, self ));
12035+ }
12036+ arg1 = (mrcImage *)(argp1);
12037+ result = (mrcImageTailer *) ((arg1)->Tailer);
12038+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageTailer, 0 | 0 );
12039+ return vresult;
12040+fail:
12041+ return Qnil;
12042+}
12043+
12044+
12045+SWIGINTERN VALUE
12046+_wrap_mrcImage_numTailer_set(int argc, VALUE *argv, VALUE self) {
12047+ mrcImage *arg1 = (mrcImage *) 0 ;
12048+ mrcImageParaTypeInteger arg2 ;
12049+ void *argp1 = 0 ;
12050+ int res1 = 0 ;
12051+ int val2 ;
12052+ int ecode2 = 0 ;
12053+
12054+ if ((argc < 1) || (argc > 1)) {
12055+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12056+ }
12057+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12058+ if (!SWIG_IsOK(res1)) {
12059+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","numTailer", 1, self ));
12060+ }
12061+ arg1 = (mrcImage *)(argp1);
12062+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
12063+ if (!SWIG_IsOK(ecode2)) {
12064+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","numTailer", 2, argv[0] ));
12065+ }
12066+ arg2 = (mrcImageParaTypeInteger)(val2);
12067+ if (arg1) (arg1)->numTailer = arg2;
12068+ return Qnil;
12069+fail:
12070+ return Qnil;
12071+}
12072+
12073+
12074+SWIGINTERN VALUE
12075+_wrap_mrcImage_numTailer_get(int argc, VALUE *argv, VALUE self) {
12076+ mrcImage *arg1 = (mrcImage *) 0 ;
12077+ void *argp1 = 0 ;
12078+ int res1 = 0 ;
12079+ mrcImageParaTypeInteger result;
12080+ VALUE vresult = Qnil;
12081+
12082+ if ((argc < 0) || (argc > 0)) {
12083+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12084+ }
12085+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12086+ if (!SWIG_IsOK(res1)) {
12087+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","numTailer", 1, self ));
12088+ }
12089+ arg1 = (mrcImage *)(argp1);
12090+ result = (mrcImageParaTypeInteger) ((arg1)->numTailer);
12091+ vresult = SWIG_From_int((int)(result));
12092+ return vresult;
12093+fail:
12094+ return Qnil;
12095+}
12096+
12097+
12098+SWIGINTERN VALUE
12099+_wrap_mrcImage_FEIHeader_set(int argc, VALUE *argv, VALUE self) {
12100+ mrcImage *arg1 = (mrcImage *) 0 ;
12101+ FEIextendedHeader *arg2 = (FEIextendedHeader *) 0 ;
12102+ void *argp1 = 0 ;
12103+ int res1 = 0 ;
12104+ void *argp2 = 0 ;
12105+ int res2 = 0 ;
12106+
12107+ if ((argc < 1) || (argc > 1)) {
12108+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12109+ }
12110+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12111+ if (!SWIG_IsOK(res1)) {
12112+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","FEIHeader", 1, self ));
12113+ }
12114+ arg1 = (mrcImage *)(argp1);
12115+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_FEIextendedHeader, SWIG_POINTER_DISOWN | 0 );
12116+ if (!SWIG_IsOK(res2)) {
12117+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FEIextendedHeader *","FEIHeader", 2, argv[0] ));
12118+ }
12119+ arg2 = (FEIextendedHeader *)(argp2);
12120+ if (arg1) (arg1)->FEIHeader = arg2;
12121+ return Qnil;
12122+fail:
12123+ return Qnil;
12124+}
12125+
12126+
12127+SWIGINTERN VALUE
12128+_wrap_mrcImage_FEIHeader_get(int argc, VALUE *argv, VALUE self) {
12129+ mrcImage *arg1 = (mrcImage *) 0 ;
12130+ void *argp1 = 0 ;
12131+ int res1 = 0 ;
12132+ FEIextendedHeader *result = 0 ;
12133+ VALUE vresult = Qnil;
12134+
12135+ if ((argc < 0) || (argc > 0)) {
12136+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12137+ }
12138+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12139+ if (!SWIG_IsOK(res1)) {
12140+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","FEIHeader", 1, self ));
12141+ }
12142+ arg1 = (mrcImage *)(argp1);
12143+ result = (FEIextendedHeader *) ((arg1)->FEIHeader);
12144+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FEIextendedHeader, 0 | 0 );
12145+ return vresult;
12146+fail:
12147+ return Qnil;
12148+}
12149+
12150+
12151+SWIGINTERN VALUE
12152+_wrap_mrcImage_numFEIHeader_set(int argc, VALUE *argv, VALUE self) {
12153+ mrcImage *arg1 = (mrcImage *) 0 ;
12154+ mrcImageParaTypeInteger arg2 ;
12155+ void *argp1 = 0 ;
12156+ int res1 = 0 ;
12157+ int val2 ;
12158+ int ecode2 = 0 ;
12159+
12160+ if ((argc < 1) || (argc > 1)) {
12161+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12162+ }
12163+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12164+ if (!SWIG_IsOK(res1)) {
12165+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","numFEIHeader", 1, self ));
12166+ }
12167+ arg1 = (mrcImage *)(argp1);
12168+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
12169+ if (!SWIG_IsOK(ecode2)) {
12170+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","numFEIHeader", 2, argv[0] ));
12171+ }
12172+ arg2 = (mrcImageParaTypeInteger)(val2);
12173+ if (arg1) (arg1)->numFEIHeader = arg2;
12174+ return Qnil;
12175+fail:
12176+ return Qnil;
12177+}
12178+
12179+
12180+SWIGINTERN VALUE
12181+_wrap_mrcImage_numFEIHeader_get(int argc, VALUE *argv, VALUE self) {
12182+ mrcImage *arg1 = (mrcImage *) 0 ;
12183+ void *argp1 = 0 ;
12184+ int res1 = 0 ;
12185+ mrcImageParaTypeInteger result;
12186+ VALUE vresult = Qnil;
12187+
12188+ if ((argc < 0) || (argc > 0)) {
12189+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12190+ }
12191+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12192+ if (!SWIG_IsOK(res1)) {
12193+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","numFEIHeader", 1, self ));
12194+ }
12195+ arg1 = (mrcImage *)(argp1);
12196+ result = (mrcImageParaTypeInteger) ((arg1)->numFEIHeader);
12197+ vresult = SWIG_From_int((int)(result));
12198+ return vresult;
12199+fail:
12200+ return Qnil;
12201+}
12202+
12203+
12204+SWIGINTERN VALUE
12205+_wrap_mrcImage_dummyHeader_set(int argc, VALUE *argv, VALUE self) {
12206+ mrcImage *arg1 = (mrcImage *) 0 ;
12207+ char *arg2 = (char *) 0 ;
12208+ void *argp1 = 0 ;
12209+ int res1 = 0 ;
12210+ int res2 ;
12211+ char *buf2 = 0 ;
12212+ int alloc2 = 0 ;
12213+
12214+ if ((argc < 1) || (argc > 1)) {
12215+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12216+ }
12217+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12218+ if (!SWIG_IsOK(res1)) {
12219+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","dummyHeader", 1, self ));
12220+ }
12221+ arg1 = (mrcImage *)(argp1);
12222+ res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12223+ if (!SWIG_IsOK(res2)) {
12224+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","dummyHeader", 2, argv[0] ));
12225+ }
12226+ arg2 = (char *)(buf2);
12227+ if (arg1->dummyHeader) free((char*)arg1->dummyHeader);
12228+ if (arg2) {
12229+ size_t size = strlen((const char *)(arg2)) + 1;
12230+ arg1->dummyHeader = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
12231+ } else {
12232+ arg1->dummyHeader = 0;
12233+ }
12234+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12235+ return Qnil;
12236+fail:
12237+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12238+ return Qnil;
12239+}
12240+
12241+
12242+SWIGINTERN VALUE
12243+_wrap_mrcImage_dummyHeader_get(int argc, VALUE *argv, VALUE self) {
12244+ mrcImage *arg1 = (mrcImage *) 0 ;
12245+ void *argp1 = 0 ;
12246+ int res1 = 0 ;
12247+ char *result = 0 ;
12248+ VALUE vresult = Qnil;
12249+
12250+ if ((argc < 0) || (argc > 0)) {
12251+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12252+ }
12253+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12254+ if (!SWIG_IsOK(res1)) {
12255+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","dummyHeader", 1, self ));
12256+ }
12257+ arg1 = (mrcImage *)(argp1);
12258+ result = (char *) ((arg1)->dummyHeader);
12259+ vresult = SWIG_FromCharPtr((const char *)result);
12260+ return vresult;
12261+fail:
12262+ return Qnil;
12263+}
12264+
12265+
12266+SWIGINTERN VALUE
12267+_wrap_mrcImage_dummyHeaderByte_set(int argc, VALUE *argv, VALUE self) {
12268+ mrcImage *arg1 = (mrcImage *) 0 ;
12269+ mrcImageParaTypeInteger arg2 ;
12270+ void *argp1 = 0 ;
12271+ int res1 = 0 ;
12272+ int val2 ;
12273+ int ecode2 = 0 ;
12274+
12275+ if ((argc < 1) || (argc > 1)) {
12276+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12277+ }
12278+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12279+ if (!SWIG_IsOK(res1)) {
12280+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","dummyHeaderByte", 1, self ));
12281+ }
12282+ arg1 = (mrcImage *)(argp1);
12283+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
12284+ if (!SWIG_IsOK(ecode2)) {
12285+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","dummyHeaderByte", 2, argv[0] ));
12286+ }
12287+ arg2 = (mrcImageParaTypeInteger)(val2);
12288+ if (arg1) (arg1)->dummyHeaderByte = arg2;
12289+ return Qnil;
12290+fail:
12291+ return Qnil;
12292+}
12293+
12294+
12295+SWIGINTERN VALUE
12296+_wrap_mrcImage_dummyHeaderByte_get(int argc, VALUE *argv, VALUE self) {
12297+ mrcImage *arg1 = (mrcImage *) 0 ;
12298+ void *argp1 = 0 ;
12299+ int res1 = 0 ;
12300+ mrcImageParaTypeInteger result;
12301+ VALUE vresult = Qnil;
12302+
12303+ if ((argc < 0) || (argc > 0)) {
12304+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12305+ }
12306+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12307+ if (!SWIG_IsOK(res1)) {
12308+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","dummyHeaderByte", 1, self ));
12309+ }
12310+ arg1 = (mrcImage *)(argp1);
12311+ result = (mrcImageParaTypeInteger) ((arg1)->dummyHeaderByte);
12312+ vresult = SWIG_From_int((int)(result));
12313+ return vresult;
12314+fail:
12315+ return Qnil;
12316+}
12317+
12318+
12319+SWIGINTERN VALUE
12320+_wrap_mrcImage_flagByteSwap_set(int argc, VALUE *argv, VALUE self) {
12321+ mrcImage *arg1 = (mrcImage *) 0 ;
12322+ mrcImageParaTypeInteger arg2 ;
12323+ void *argp1 = 0 ;
12324+ int res1 = 0 ;
12325+ int val2 ;
12326+ int ecode2 = 0 ;
12327+
12328+ if ((argc < 1) || (argc > 1)) {
12329+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12330+ }
12331+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12332+ if (!SWIG_IsOK(res1)) {
12333+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","flagByteSwap", 1, self ));
12334+ }
12335+ arg1 = (mrcImage *)(argp1);
12336+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
12337+ if (!SWIG_IsOK(ecode2)) {
12338+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","flagByteSwap", 2, argv[0] ));
12339+ }
12340+ arg2 = (mrcImageParaTypeInteger)(val2);
12341+ if (arg1) (arg1)->flagByteSwap = arg2;
12342+ return Qnil;
12343+fail:
12344+ return Qnil;
12345+}
12346+
12347+
12348+SWIGINTERN VALUE
12349+_wrap_mrcImage_flagByteSwap_get(int argc, VALUE *argv, VALUE self) {
12350+ mrcImage *arg1 = (mrcImage *) 0 ;
12351+ void *argp1 = 0 ;
12352+ int res1 = 0 ;
12353+ mrcImageParaTypeInteger result;
12354+ VALUE vresult = Qnil;
12355+
12356+ if ((argc < 0) || (argc > 0)) {
12357+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12358+ }
12359+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12360+ if (!SWIG_IsOK(res1)) {
12361+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","flagByteSwap", 1, self ));
12362+ }
12363+ arg1 = (mrcImage *)(argp1);
12364+ result = (mrcImageParaTypeInteger) ((arg1)->flagByteSwap);
12365+ vresult = SWIG_From_int((int)(result));
12366+ return vresult;
12367+fail:
12368+ return Qnil;
12369+}
12370+
12371+
12372+SWIGINTERN VALUE
12373+_wrap_mrcImage_flagCCP4_set(int argc, VALUE *argv, VALUE self) {
12374+ mrcImage *arg1 = (mrcImage *) 0 ;
12375+ mrcImageParaTypeInteger arg2 ;
12376+ void *argp1 = 0 ;
12377+ int res1 = 0 ;
12378+ int val2 ;
12379+ int ecode2 = 0 ;
12380+
12381+ if ((argc < 1) || (argc > 1)) {
12382+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12383+ }
12384+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12385+ if (!SWIG_IsOK(res1)) {
12386+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","flagCCP4", 1, self ));
12387+ }
12388+ arg1 = (mrcImage *)(argp1);
12389+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
12390+ if (!SWIG_IsOK(ecode2)) {
12391+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","flagCCP4", 2, argv[0] ));
12392+ }
12393+ arg2 = (mrcImageParaTypeInteger)(val2);
12394+ if (arg1) (arg1)->flagCCP4 = arg2;
12395+ return Qnil;
12396+fail:
12397+ return Qnil;
12398+}
12399+
12400+
12401+SWIGINTERN VALUE
12402+_wrap_mrcImage_flagCCP4_get(int argc, VALUE *argv, VALUE self) {
12403+ mrcImage *arg1 = (mrcImage *) 0 ;
12404+ void *argp1 = 0 ;
12405+ int res1 = 0 ;
12406+ mrcImageParaTypeInteger result;
12407+ VALUE vresult = Qnil;
12408+
12409+ if ((argc < 0) || (argc > 0)) {
12410+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12411+ }
12412+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12413+ if (!SWIG_IsOK(res1)) {
12414+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","flagCCP4", 1, self ));
12415+ }
12416+ arg1 = (mrcImage *)(argp1);
12417+ result = (mrcImageParaTypeInteger) ((arg1)->flagCCP4);
12418+ vresult = SWIG_From_int((int)(result));
12419+ return vresult;
12420+fail:
12421+ return Qnil;
12422+}
12423+
12424+
12425+SWIGINTERN VALUE
12426+_wrap_mrcImage_ImageOffset_set(int argc, VALUE *argv, VALUE self) {
12427+ mrcImage *arg1 = (mrcImage *) 0 ;
12428+ mrcImageParaTypeInteger arg2 ;
12429+ void *argp1 = 0 ;
12430+ int res1 = 0 ;
12431+ int val2 ;
12432+ int ecode2 = 0 ;
12433+
12434+ if ((argc < 1) || (argc > 1)) {
12435+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12436+ }
12437+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12438+ if (!SWIG_IsOK(res1)) {
12439+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageOffset", 1, self ));
12440+ }
12441+ arg1 = (mrcImage *)(argp1);
12442+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
12443+ if (!SWIG_IsOK(ecode2)) {
12444+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeInteger","ImageOffset", 2, argv[0] ));
12445+ }
12446+ arg2 = (mrcImageParaTypeInteger)(val2);
12447+ if (arg1) (arg1)->ImageOffset = arg2;
12448+ return Qnil;
12449+fail:
12450+ return Qnil;
12451+}
12452+
12453+
12454+SWIGINTERN VALUE
12455+_wrap_mrcImage_ImageOffset_get(int argc, VALUE *argv, VALUE self) {
12456+ mrcImage *arg1 = (mrcImage *) 0 ;
12457+ void *argp1 = 0 ;
12458+ int res1 = 0 ;
12459+ mrcImageParaTypeInteger result;
12460+ VALUE vresult = Qnil;
12461+
12462+ if ((argc < 0) || (argc > 0)) {
12463+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12464+ }
12465+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12466+ if (!SWIG_IsOK(res1)) {
12467+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","ImageOffset", 1, self ));
12468+ }
12469+ arg1 = (mrcImage *)(argp1);
12470+ result = (mrcImageParaTypeInteger) ((arg1)->ImageOffset);
12471+ vresult = SWIG_From_int((int)(result));
12472+ return vresult;
12473+fail:
12474+ return Qnil;
12475+}
12476+
12477+
12478+SWIGINTERN VALUE
12479+_wrap_mrcImage_SymmetryOperator_set(int argc, VALUE *argv, VALUE self) {
12480+ mrcImage *arg1 = (mrcImage *) 0 ;
12481+ mrcImageSymmetryOperator *arg2 = (mrcImageSymmetryOperator *) 0 ;
12482+ void *argp1 = 0 ;
12483+ int res1 = 0 ;
12484+ int res2 ;
12485+ char *buf2 = 0 ;
12486+ int alloc2 = 0 ;
12487+
12488+ if ((argc < 1) || (argc > 1)) {
12489+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12490+ }
12491+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12492+ if (!SWIG_IsOK(res1)) {
12493+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","SymmetryOperator", 1, self ));
12494+ }
12495+ arg1 = (mrcImage *)(argp1);
12496+ res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
12497+ if (!SWIG_IsOK(res2)) {
12498+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageSymmetryOperator *","SymmetryOperator", 2, argv[0] ));
12499+ }
12500+ arg2 = (mrcImageSymmetryOperator *)(buf2);
12501+ if (arg1->SymmetryOperator) free((char*)arg1->SymmetryOperator);
12502+ if (arg2) {
12503+ size_t size = strlen((const char *)(arg2)) + 1;
12504+ arg1->SymmetryOperator = (mrcImageSymmetryOperator *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
12505+ } else {
12506+ arg1->SymmetryOperator = 0;
12507+ }
12508+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12509+ return Qnil;
12510+fail:
12511+ if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12512+ return Qnil;
12513+}
12514+
12515+
12516+SWIGINTERN VALUE
12517+_wrap_mrcImage_SymmetryOperator_get(int argc, VALUE *argv, VALUE self) {
12518+ mrcImage *arg1 = (mrcImage *) 0 ;
12519+ void *argp1 = 0 ;
12520+ int res1 = 0 ;
12521+ mrcImageSymmetryOperator *result = 0 ;
12522+ VALUE vresult = Qnil;
12523+
12524+ if ((argc < 0) || (argc > 0)) {
12525+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12526+ }
12527+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImage, 0 | 0 );
12528+ if (!SWIG_IsOK(res1)) {
12529+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImage *","SymmetryOperator", 1, self ));
12530+ }
12531+ arg1 = (mrcImage *)(argp1);
12532+ result = (mrcImageSymmetryOperator *) ((arg1)->SymmetryOperator);
12533+ vresult = SWIG_FromCharPtr((const char *)result);
12534+ return vresult;
12535+fail:
12536+ return Qnil;
12537+}
12538+
12539+
12540+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
12541+SWIGINTERN VALUE
12542+_wrap_mrcImage_allocate(VALUE self) {
12543+#else
12544+ SWIGINTERN VALUE
12545+ _wrap_mrcImage_allocate(int argc, VALUE *argv, VALUE self) {
12546+#endif
12547+
12548+
12549+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_mrcImage);
12550+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
12551+ rb_obj_call_init(vresult, argc, argv);
12552+#endif
12553+ return vresult;
12554+ }
12555+
12556+
12557+SWIGINTERN VALUE
12558+_wrap_new_mrcImage(int argc, VALUE *argv, VALUE self) {
12559+ mrcImage *result = 0 ;
12560+
12561+ if ((argc < 0) || (argc > 0)) {
12562+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12563+ }
12564+ result = (mrcImage *)calloc(1, sizeof(mrcImage));
12565+ DATA_PTR(self) = result;
12566+ return self;
12567+fail:
12568+ return Qnil;
12569+}
12570+
12571+
12572+SWIGINTERN void
12573+free_mrcImage(mrcImage *arg1) {
12574+ free((char *) arg1);
12575+}
12576+
12577+swig_class SwigClassMrcImageInformation;
12578+
12579+SWIGINTERN VALUE
12580+_wrap_mrcImageInformation_mean_set(int argc, VALUE *argv, VALUE self) {
12581+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12582+ double arg2 ;
12583+ void *argp1 = 0 ;
12584+ int res1 = 0 ;
12585+ double val2 ;
12586+ int ecode2 = 0 ;
12587+
12588+ if ((argc < 1) || (argc > 1)) {
12589+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12590+ }
12591+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12592+ if (!SWIG_IsOK(res1)) {
12593+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","mean", 1, self ));
12594+ }
12595+ arg1 = (mrcImageInformation *)(argp1);
12596+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
12597+ if (!SWIG_IsOK(ecode2)) {
12598+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","mean", 2, argv[0] ));
12599+ }
12600+ arg2 = (double)(val2);
12601+ if (arg1) (arg1)->mean = arg2;
12602+ return Qnil;
12603+fail:
12604+ return Qnil;
12605+}
12606+
12607+
12608+SWIGINTERN VALUE
12609+_wrap_mrcImageInformation_mean_get(int argc, VALUE *argv, VALUE self) {
12610+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12611+ void *argp1 = 0 ;
12612+ int res1 = 0 ;
12613+ double result;
12614+ VALUE vresult = Qnil;
12615+
12616+ if ((argc < 0) || (argc > 0)) {
12617+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12618+ }
12619+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12620+ if (!SWIG_IsOK(res1)) {
12621+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","mean", 1, self ));
12622+ }
12623+ arg1 = (mrcImageInformation *)(argp1);
12624+ result = (double) ((arg1)->mean);
12625+ vresult = SWIG_From_double((double)(result));
12626+ return vresult;
12627+fail:
12628+ return Qnil;
12629+}
12630+
12631+
12632+SWIGINTERN VALUE
12633+_wrap_mrcImageInformation_rootMeanSquare_set(int argc, VALUE *argv, VALUE self) {
12634+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12635+ double arg2 ;
12636+ void *argp1 = 0 ;
12637+ int res1 = 0 ;
12638+ double val2 ;
12639+ int ecode2 = 0 ;
12640+
12641+ if ((argc < 1) || (argc > 1)) {
12642+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12643+ }
12644+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12645+ if (!SWIG_IsOK(res1)) {
12646+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","rootMeanSquare", 1, self ));
12647+ }
12648+ arg1 = (mrcImageInformation *)(argp1);
12649+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
12650+ if (!SWIG_IsOK(ecode2)) {
12651+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","rootMeanSquare", 2, argv[0] ));
12652+ }
12653+ arg2 = (double)(val2);
12654+ if (arg1) (arg1)->rootMeanSquare = arg2;
12655+ return Qnil;
12656+fail:
12657+ return Qnil;
12658+}
12659+
12660+
12661+SWIGINTERN VALUE
12662+_wrap_mrcImageInformation_rootMeanSquare_get(int argc, VALUE *argv, VALUE self) {
12663+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12664+ void *argp1 = 0 ;
12665+ int res1 = 0 ;
12666+ double result;
12667+ VALUE vresult = Qnil;
12668+
12669+ if ((argc < 0) || (argc > 0)) {
12670+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12671+ }
12672+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12673+ if (!SWIG_IsOK(res1)) {
12674+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","rootMeanSquare", 1, self ));
12675+ }
12676+ arg1 = (mrcImageInformation *)(argp1);
12677+ result = (double) ((arg1)->rootMeanSquare);
12678+ vresult = SWIG_From_double((double)(result));
12679+ return vresult;
12680+fail:
12681+ return Qnil;
12682+}
12683+
12684+
12685+SWIGINTERN VALUE
12686+_wrap_mrcImageInformation_meanOfSphereSurface_set(int argc, VALUE *argv, VALUE self) {
12687+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12688+ double arg2 ;
12689+ void *argp1 = 0 ;
12690+ int res1 = 0 ;
12691+ double val2 ;
12692+ int ecode2 = 0 ;
12693+
12694+ if ((argc < 1) || (argc > 1)) {
12695+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12696+ }
12697+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12698+ if (!SWIG_IsOK(res1)) {
12699+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","meanOfSphereSurface", 1, self ));
12700+ }
12701+ arg1 = (mrcImageInformation *)(argp1);
12702+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
12703+ if (!SWIG_IsOK(ecode2)) {
12704+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","meanOfSphereSurface", 2, argv[0] ));
12705+ }
12706+ arg2 = (double)(val2);
12707+ if (arg1) (arg1)->meanOfSphereSurface = arg2;
12708+ return Qnil;
12709+fail:
12710+ return Qnil;
12711+}
12712+
12713+
12714+SWIGINTERN VALUE
12715+_wrap_mrcImageInformation_meanOfSphereSurface_get(int argc, VALUE *argv, VALUE self) {
12716+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12717+ void *argp1 = 0 ;
12718+ int res1 = 0 ;
12719+ double result;
12720+ VALUE vresult = Qnil;
12721+
12722+ if ((argc < 0) || (argc > 0)) {
12723+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12724+ }
12725+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12726+ if (!SWIG_IsOK(res1)) {
12727+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","meanOfSphereSurface", 1, self ));
12728+ }
12729+ arg1 = (mrcImageInformation *)(argp1);
12730+ result = (double) ((arg1)->meanOfSphereSurface);
12731+ vresult = SWIG_From_double((double)(result));
12732+ return vresult;
12733+fail:
12734+ return Qnil;
12735+}
12736+
12737+
12738+SWIGINTERN VALUE
12739+_wrap_mrcImageInformation_sdOfSphereSurface_set(int argc, VALUE *argv, VALUE self) {
12740+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12741+ double arg2 ;
12742+ void *argp1 = 0 ;
12743+ int res1 = 0 ;
12744+ double val2 ;
12745+ int ecode2 = 0 ;
12746+
12747+ if ((argc < 1) || (argc > 1)) {
12748+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12749+ }
12750+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12751+ if (!SWIG_IsOK(res1)) {
12752+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","sdOfSphereSurface", 1, self ));
12753+ }
12754+ arg1 = (mrcImageInformation *)(argp1);
12755+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
12756+ if (!SWIG_IsOK(ecode2)) {
12757+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","sdOfSphereSurface", 2, argv[0] ));
12758+ }
12759+ arg2 = (double)(val2);
12760+ if (arg1) (arg1)->sdOfSphereSurface = arg2;
12761+ return Qnil;
12762+fail:
12763+ return Qnil;
12764+}
12765+
12766+
12767+SWIGINTERN VALUE
12768+_wrap_mrcImageInformation_sdOfSphereSurface_get(int argc, VALUE *argv, VALUE self) {
12769+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12770+ void *argp1 = 0 ;
12771+ int res1 = 0 ;
12772+ double result;
12773+ VALUE vresult = Qnil;
12774+
12775+ if ((argc < 0) || (argc > 0)) {
12776+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12777+ }
12778+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12779+ if (!SWIG_IsOK(res1)) {
12780+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","sdOfSphereSurface", 1, self ));
12781+ }
12782+ arg1 = (mrcImageInformation *)(argp1);
12783+ result = (double) ((arg1)->sdOfSphereSurface);
12784+ vresult = SWIG_From_double((double)(result));
12785+ return vresult;
12786+fail:
12787+ return Qnil;
12788+}
12789+
12790+
12791+SWIGINTERN VALUE
12792+_wrap_mrcImageInformation_seOfSphereSurface_set(int argc, VALUE *argv, VALUE self) {
12793+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12794+ double arg2 ;
12795+ void *argp1 = 0 ;
12796+ int res1 = 0 ;
12797+ double val2 ;
12798+ int ecode2 = 0 ;
12799+
12800+ if ((argc < 1) || (argc > 1)) {
12801+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12802+ }
12803+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12804+ if (!SWIG_IsOK(res1)) {
12805+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","seOfSphereSurface", 1, self ));
12806+ }
12807+ arg1 = (mrcImageInformation *)(argp1);
12808+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
12809+ if (!SWIG_IsOK(ecode2)) {
12810+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","seOfSphereSurface", 2, argv[0] ));
12811+ }
12812+ arg2 = (double)(val2);
12813+ if (arg1) (arg1)->seOfSphereSurface = arg2;
12814+ return Qnil;
12815+fail:
12816+ return Qnil;
12817+}
12818+
12819+
12820+SWIGINTERN VALUE
12821+_wrap_mrcImageInformation_seOfSphereSurface_get(int argc, VALUE *argv, VALUE self) {
12822+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12823+ void *argp1 = 0 ;
12824+ int res1 = 0 ;
12825+ double result;
12826+ VALUE vresult = Qnil;
12827+
12828+ if ((argc < 0) || (argc > 0)) {
12829+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12830+ }
12831+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12832+ if (!SWIG_IsOK(res1)) {
12833+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","seOfSphereSurface", 1, self ));
12834+ }
12835+ arg1 = (mrcImageInformation *)(argp1);
12836+ result = (double) ((arg1)->seOfSphereSurface);
12837+ vresult = SWIG_From_double((double)(result));
12838+ return vresult;
12839+fail:
12840+ return Qnil;
12841+}
12842+
12843+
12844+SWIGINTERN VALUE
12845+_wrap_mrcImageInformation_meanOfCylinderSurface_set(int argc, VALUE *argv, VALUE self) {
12846+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12847+ double arg2 ;
12848+ void *argp1 = 0 ;
12849+ int res1 = 0 ;
12850+ double val2 ;
12851+ int ecode2 = 0 ;
12852+
12853+ if ((argc < 1) || (argc > 1)) {
12854+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12855+ }
12856+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12857+ if (!SWIG_IsOK(res1)) {
12858+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","meanOfCylinderSurface", 1, self ));
12859+ }
12860+ arg1 = (mrcImageInformation *)(argp1);
12861+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
12862+ if (!SWIG_IsOK(ecode2)) {
12863+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","meanOfCylinderSurface", 2, argv[0] ));
12864+ }
12865+ arg2 = (double)(val2);
12866+ if (arg1) (arg1)->meanOfCylinderSurface = arg2;
12867+ return Qnil;
12868+fail:
12869+ return Qnil;
12870+}
12871+
12872+
12873+SWIGINTERN VALUE
12874+_wrap_mrcImageInformation_meanOfCylinderSurface_get(int argc, VALUE *argv, VALUE self) {
12875+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12876+ void *argp1 = 0 ;
12877+ int res1 = 0 ;
12878+ double result;
12879+ VALUE vresult = Qnil;
12880+
12881+ if ((argc < 0) || (argc > 0)) {
12882+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12883+ }
12884+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12885+ if (!SWIG_IsOK(res1)) {
12886+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","meanOfCylinderSurface", 1, self ));
12887+ }
12888+ arg1 = (mrcImageInformation *)(argp1);
12889+ result = (double) ((arg1)->meanOfCylinderSurface);
12890+ vresult = SWIG_From_double((double)(result));
12891+ return vresult;
12892+fail:
12893+ return Qnil;
12894+}
12895+
12896+
12897+SWIGINTERN VALUE
12898+_wrap_mrcImageInformation_sdOfCylinderSurface_set(int argc, VALUE *argv, VALUE self) {
12899+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12900+ double arg2 ;
12901+ void *argp1 = 0 ;
12902+ int res1 = 0 ;
12903+ double val2 ;
12904+ int ecode2 = 0 ;
12905+
12906+ if ((argc < 1) || (argc > 1)) {
12907+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12908+ }
12909+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12910+ if (!SWIG_IsOK(res1)) {
12911+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","sdOfCylinderSurface", 1, self ));
12912+ }
12913+ arg1 = (mrcImageInformation *)(argp1);
12914+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
12915+ if (!SWIG_IsOK(ecode2)) {
12916+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","sdOfCylinderSurface", 2, argv[0] ));
12917+ }
12918+ arg2 = (double)(val2);
12919+ if (arg1) (arg1)->sdOfCylinderSurface = arg2;
12920+ return Qnil;
12921+fail:
12922+ return Qnil;
12923+}
12924+
12925+
12926+SWIGINTERN VALUE
12927+_wrap_mrcImageInformation_sdOfCylinderSurface_get(int argc, VALUE *argv, VALUE self) {
12928+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12929+ void *argp1 = 0 ;
12930+ int res1 = 0 ;
12931+ double result;
12932+ VALUE vresult = Qnil;
12933+
12934+ if ((argc < 0) || (argc > 0)) {
12935+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12936+ }
12937+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12938+ if (!SWIG_IsOK(res1)) {
12939+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","sdOfCylinderSurface", 1, self ));
12940+ }
12941+ arg1 = (mrcImageInformation *)(argp1);
12942+ result = (double) ((arg1)->sdOfCylinderSurface);
12943+ vresult = SWIG_From_double((double)(result));
12944+ return vresult;
12945+fail:
12946+ return Qnil;
12947+}
12948+
12949+
12950+SWIGINTERN VALUE
12951+_wrap_mrcImageInformation_seOfCylinderSurface_set(int argc, VALUE *argv, VALUE self) {
12952+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12953+ double arg2 ;
12954+ void *argp1 = 0 ;
12955+ int res1 = 0 ;
12956+ double val2 ;
12957+ int ecode2 = 0 ;
12958+
12959+ if ((argc < 1) || (argc > 1)) {
12960+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
12961+ }
12962+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12963+ if (!SWIG_IsOK(res1)) {
12964+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","seOfCylinderSurface", 1, self ));
12965+ }
12966+ arg1 = (mrcImageInformation *)(argp1);
12967+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
12968+ if (!SWIG_IsOK(ecode2)) {
12969+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","seOfCylinderSurface", 2, argv[0] ));
12970+ }
12971+ arg2 = (double)(val2);
12972+ if (arg1) (arg1)->seOfCylinderSurface = arg2;
12973+ return Qnil;
12974+fail:
12975+ return Qnil;
12976+}
12977+
12978+
12979+SWIGINTERN VALUE
12980+_wrap_mrcImageInformation_seOfCylinderSurface_get(int argc, VALUE *argv, VALUE self) {
12981+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
12982+ void *argp1 = 0 ;
12983+ int res1 = 0 ;
12984+ double result;
12985+ VALUE vresult = Qnil;
12986+
12987+ if ((argc < 0) || (argc > 0)) {
12988+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
12989+ }
12990+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
12991+ if (!SWIG_IsOK(res1)) {
12992+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","seOfCylinderSurface", 1, self ));
12993+ }
12994+ arg1 = (mrcImageInformation *)(argp1);
12995+ result = (double) ((arg1)->seOfCylinderSurface);
12996+ vresult = SWIG_From_double((double)(result));
12997+ return vresult;
12998+fail:
12999+ return Qnil;
13000+}
13001+
13002+
13003+SWIGINTERN VALUE
13004+_wrap_mrcImageInformation_meanOfEdge_set(int argc, VALUE *argv, VALUE self) {
13005+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13006+ double arg2 ;
13007+ void *argp1 = 0 ;
13008+ int res1 = 0 ;
13009+ double val2 ;
13010+ int ecode2 = 0 ;
13011+
13012+ if ((argc < 1) || (argc > 1)) {
13013+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13014+ }
13015+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13016+ if (!SWIG_IsOK(res1)) {
13017+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","meanOfEdge", 1, self ));
13018+ }
13019+ arg1 = (mrcImageInformation *)(argp1);
13020+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13021+ if (!SWIG_IsOK(ecode2)) {
13022+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","meanOfEdge", 2, argv[0] ));
13023+ }
13024+ arg2 = (double)(val2);
13025+ if (arg1) (arg1)->meanOfEdge = arg2;
13026+ return Qnil;
13027+fail:
13028+ return Qnil;
13029+}
13030+
13031+
13032+SWIGINTERN VALUE
13033+_wrap_mrcImageInformation_meanOfEdge_get(int argc, VALUE *argv, VALUE self) {
13034+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13035+ void *argp1 = 0 ;
13036+ int res1 = 0 ;
13037+ double result;
13038+ VALUE vresult = Qnil;
13039+
13040+ if ((argc < 0) || (argc > 0)) {
13041+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13042+ }
13043+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13044+ if (!SWIG_IsOK(res1)) {
13045+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","meanOfEdge", 1, self ));
13046+ }
13047+ arg1 = (mrcImageInformation *)(argp1);
13048+ result = (double) ((arg1)->meanOfEdge);
13049+ vresult = SWIG_From_double((double)(result));
13050+ return vresult;
13051+fail:
13052+ return Qnil;
13053+}
13054+
13055+
13056+SWIGINTERN VALUE
13057+_wrap_mrcImageInformation_sdOfEdge_set(int argc, VALUE *argv, VALUE self) {
13058+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13059+ double arg2 ;
13060+ void *argp1 = 0 ;
13061+ int res1 = 0 ;
13062+ double val2 ;
13063+ int ecode2 = 0 ;
13064+
13065+ if ((argc < 1) || (argc > 1)) {
13066+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13067+ }
13068+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13069+ if (!SWIG_IsOK(res1)) {
13070+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","sdOfEdge", 1, self ));
13071+ }
13072+ arg1 = (mrcImageInformation *)(argp1);
13073+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13074+ if (!SWIG_IsOK(ecode2)) {
13075+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","sdOfEdge", 2, argv[0] ));
13076+ }
13077+ arg2 = (double)(val2);
13078+ if (arg1) (arg1)->sdOfEdge = arg2;
13079+ return Qnil;
13080+fail:
13081+ return Qnil;
13082+}
13083+
13084+
13085+SWIGINTERN VALUE
13086+_wrap_mrcImageInformation_sdOfEdge_get(int argc, VALUE *argv, VALUE self) {
13087+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13088+ void *argp1 = 0 ;
13089+ int res1 = 0 ;
13090+ double result;
13091+ VALUE vresult = Qnil;
13092+
13093+ if ((argc < 0) || (argc > 0)) {
13094+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13095+ }
13096+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13097+ if (!SWIG_IsOK(res1)) {
13098+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","sdOfEdge", 1, self ));
13099+ }
13100+ arg1 = (mrcImageInformation *)(argp1);
13101+ result = (double) ((arg1)->sdOfEdge);
13102+ vresult = SWIG_From_double((double)(result));
13103+ return vresult;
13104+fail:
13105+ return Qnil;
13106+}
13107+
13108+
13109+SWIGINTERN VALUE
13110+_wrap_mrcImageInformation_seOfEdge_set(int argc, VALUE *argv, VALUE self) {
13111+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13112+ double arg2 ;
13113+ void *argp1 = 0 ;
13114+ int res1 = 0 ;
13115+ double val2 ;
13116+ int ecode2 = 0 ;
13117+
13118+ if ((argc < 1) || (argc > 1)) {
13119+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13120+ }
13121+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13122+ if (!SWIG_IsOK(res1)) {
13123+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","seOfEdge", 1, self ));
13124+ }
13125+ arg1 = (mrcImageInformation *)(argp1);
13126+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13127+ if (!SWIG_IsOK(ecode2)) {
13128+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","seOfEdge", 2, argv[0] ));
13129+ }
13130+ arg2 = (double)(val2);
13131+ if (arg1) (arg1)->seOfEdge = arg2;
13132+ return Qnil;
13133+fail:
13134+ return Qnil;
13135+}
13136+
13137+
13138+SWIGINTERN VALUE
13139+_wrap_mrcImageInformation_seOfEdge_get(int argc, VALUE *argv, VALUE self) {
13140+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13141+ void *argp1 = 0 ;
13142+ int res1 = 0 ;
13143+ double result;
13144+ VALUE vresult = Qnil;
13145+
13146+ if ((argc < 0) || (argc > 0)) {
13147+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13148+ }
13149+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13150+ if (!SWIG_IsOK(res1)) {
13151+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","seOfEdge", 1, self ));
13152+ }
13153+ arg1 = (mrcImageInformation *)(argp1);
13154+ result = (double) ((arg1)->seOfEdge);
13155+ vresult = SWIG_From_double((double)(result));
13156+ return vresult;
13157+fail:
13158+ return Qnil;
13159+}
13160+
13161+
13162+SWIGINTERN VALUE
13163+_wrap_mrcImageInformation_max_set(int argc, VALUE *argv, VALUE self) {
13164+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13165+ double arg2 ;
13166+ void *argp1 = 0 ;
13167+ int res1 = 0 ;
13168+ double val2 ;
13169+ int ecode2 = 0 ;
13170+
13171+ if ((argc < 1) || (argc > 1)) {
13172+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13173+ }
13174+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13175+ if (!SWIG_IsOK(res1)) {
13176+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","max", 1, self ));
13177+ }
13178+ arg1 = (mrcImageInformation *)(argp1);
13179+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13180+ if (!SWIG_IsOK(ecode2)) {
13181+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","max", 2, argv[0] ));
13182+ }
13183+ arg2 = (double)(val2);
13184+ if (arg1) (arg1)->max = arg2;
13185+ return Qnil;
13186+fail:
13187+ return Qnil;
13188+}
13189+
13190+
13191+SWIGINTERN VALUE
13192+_wrap_mrcImageInformation_max_get(int argc, VALUE *argv, VALUE self) {
13193+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13194+ void *argp1 = 0 ;
13195+ int res1 = 0 ;
13196+ double result;
13197+ VALUE vresult = Qnil;
13198+
13199+ if ((argc < 0) || (argc > 0)) {
13200+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13201+ }
13202+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13203+ if (!SWIG_IsOK(res1)) {
13204+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","max", 1, self ));
13205+ }
13206+ arg1 = (mrcImageInformation *)(argp1);
13207+ result = (double) ((arg1)->max);
13208+ vresult = SWIG_From_double((double)(result));
13209+ return vresult;
13210+fail:
13211+ return Qnil;
13212+}
13213+
13214+
13215+SWIGINTERN VALUE
13216+_wrap_mrcImageInformation_maxCoord_set(int argc, VALUE *argv, VALUE self) {
13217+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13218+ mrcImageParaTypeRealCoord *arg2 = (mrcImageParaTypeRealCoord *) 0 ;
13219+ void *argp1 = 0 ;
13220+ int res1 = 0 ;
13221+ void *argp2 = 0 ;
13222+ int res2 = 0 ;
13223+
13224+ if ((argc < 1) || (argc > 1)) {
13225+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13226+ }
13227+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13228+ if (!SWIG_IsOK(res1)) {
13229+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","maxCoord", 1, self ));
13230+ }
13231+ arg1 = (mrcImageInformation *)(argp1);
13232+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
13233+ if (!SWIG_IsOK(res2)) {
13234+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","maxCoord", 2, argv[0] ));
13235+ }
13236+ arg2 = (mrcImageParaTypeRealCoord *)(argp2);
13237+ if (arg1) (arg1)->maxCoord = *arg2;
13238+ return Qnil;
13239+fail:
13240+ return Qnil;
13241+}
13242+
13243+
13244+SWIGINTERN VALUE
13245+_wrap_mrcImageInformation_maxCoord_get(int argc, VALUE *argv, VALUE self) {
13246+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13247+ void *argp1 = 0 ;
13248+ int res1 = 0 ;
13249+ mrcImageParaTypeRealCoord *result = 0 ;
13250+ VALUE vresult = Qnil;
13251+
13252+ if ((argc < 0) || (argc > 0)) {
13253+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13254+ }
13255+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13256+ if (!SWIG_IsOK(res1)) {
13257+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","maxCoord", 1, self ));
13258+ }
13259+ arg1 = (mrcImageInformation *)(argp1);
13260+ result = (mrcImageParaTypeRealCoord *)& ((arg1)->maxCoord);
13261+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
13262+ return vresult;
13263+fail:
13264+ return Qnil;
13265+}
13266+
13267+
13268+SWIGINTERN VALUE
13269+_wrap_mrcImageInformation_min_set(int argc, VALUE *argv, VALUE self) {
13270+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13271+ double arg2 ;
13272+ void *argp1 = 0 ;
13273+ int res1 = 0 ;
13274+ double val2 ;
13275+ int ecode2 = 0 ;
13276+
13277+ if ((argc < 1) || (argc > 1)) {
13278+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13279+ }
13280+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13281+ if (!SWIG_IsOK(res1)) {
13282+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","min", 1, self ));
13283+ }
13284+ arg1 = (mrcImageInformation *)(argp1);
13285+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13286+ if (!SWIG_IsOK(ecode2)) {
13287+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","min", 2, argv[0] ));
13288+ }
13289+ arg2 = (double)(val2);
13290+ if (arg1) (arg1)->min = arg2;
13291+ return Qnil;
13292+fail:
13293+ return Qnil;
13294+}
13295+
13296+
13297+SWIGINTERN VALUE
13298+_wrap_mrcImageInformation_min_get(int argc, VALUE *argv, VALUE self) {
13299+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13300+ void *argp1 = 0 ;
13301+ int res1 = 0 ;
13302+ double result;
13303+ VALUE vresult = Qnil;
13304+
13305+ if ((argc < 0) || (argc > 0)) {
13306+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13307+ }
13308+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13309+ if (!SWIG_IsOK(res1)) {
13310+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","min", 1, self ));
13311+ }
13312+ arg1 = (mrcImageInformation *)(argp1);
13313+ result = (double) ((arg1)->min);
13314+ vresult = SWIG_From_double((double)(result));
13315+ return vresult;
13316+fail:
13317+ return Qnil;
13318+}
13319+
13320+
13321+SWIGINTERN VALUE
13322+_wrap_mrcImageInformation_minCoord_set(int argc, VALUE *argv, VALUE self) {
13323+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13324+ mrcImageParaTypeRealCoord *arg2 = (mrcImageParaTypeRealCoord *) 0 ;
13325+ void *argp1 = 0 ;
13326+ int res1 = 0 ;
13327+ void *argp2 = 0 ;
13328+ int res2 = 0 ;
13329+
13330+ if ((argc < 1) || (argc > 1)) {
13331+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13332+ }
13333+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13334+ if (!SWIG_IsOK(res1)) {
13335+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","minCoord", 1, self ));
13336+ }
13337+ arg1 = (mrcImageInformation *)(argp1);
13338+ res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
13339+ if (!SWIG_IsOK(res2)) {
13340+ SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "mrcImageParaTypeRealCoord *","minCoord", 2, argv[0] ));
13341+ }
13342+ arg2 = (mrcImageParaTypeRealCoord *)(argp2);
13343+ if (arg1) (arg1)->minCoord = *arg2;
13344+ return Qnil;
13345+fail:
13346+ return Qnil;
13347+}
13348+
13349+
13350+SWIGINTERN VALUE
13351+_wrap_mrcImageInformation_minCoord_get(int argc, VALUE *argv, VALUE self) {
13352+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13353+ void *argp1 = 0 ;
13354+ int res1 = 0 ;
13355+ mrcImageParaTypeRealCoord *result = 0 ;
13356+ VALUE vresult = Qnil;
13357+
13358+ if ((argc < 0) || (argc > 0)) {
13359+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13360+ }
13361+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13362+ if (!SWIG_IsOK(res1)) {
13363+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","minCoord", 1, self ));
13364+ }
13365+ arg1 = (mrcImageInformation *)(argp1);
13366+ result = (mrcImageParaTypeRealCoord *)& ((arg1)->minCoord);
13367+ vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mrcImageParaTypeRealCoord, 0 | 0 );
13368+ return vresult;
13369+fail:
13370+ return Qnil;
13371+}
13372+
13373+
13374+SWIGINTERN VALUE
13375+_wrap_mrcImageInformation_sd_set(int argc, VALUE *argv, VALUE self) {
13376+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13377+ double arg2 ;
13378+ void *argp1 = 0 ;
13379+ int res1 = 0 ;
13380+ double val2 ;
13381+ int ecode2 = 0 ;
13382+
13383+ if ((argc < 1) || (argc > 1)) {
13384+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13385+ }
13386+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13387+ if (!SWIG_IsOK(res1)) {
13388+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","sd", 1, self ));
13389+ }
13390+ arg1 = (mrcImageInformation *)(argp1);
13391+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13392+ if (!SWIG_IsOK(ecode2)) {
13393+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","sd", 2, argv[0] ));
13394+ }
13395+ arg2 = (double)(val2);
13396+ if (arg1) (arg1)->sd = arg2;
13397+ return Qnil;
13398+fail:
13399+ return Qnil;
13400+}
13401+
13402+
13403+SWIGINTERN VALUE
13404+_wrap_mrcImageInformation_sd_get(int argc, VALUE *argv, VALUE self) {
13405+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13406+ void *argp1 = 0 ;
13407+ int res1 = 0 ;
13408+ double result;
13409+ VALUE vresult = Qnil;
13410+
13411+ if ((argc < 0) || (argc > 0)) {
13412+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13413+ }
13414+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13415+ if (!SWIG_IsOK(res1)) {
13416+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","sd", 1, self ));
13417+ }
13418+ arg1 = (mrcImageInformation *)(argp1);
13419+ result = (double) ((arg1)->sd);
13420+ vresult = SWIG_From_double((double)(result));
13421+ return vresult;
13422+fail:
13423+ return Qnil;
13424+}
13425+
13426+
13427+SWIGINTERN VALUE
13428+_wrap_mrcImageInformation_se_set(int argc, VALUE *argv, VALUE self) {
13429+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13430+ double arg2 ;
13431+ void *argp1 = 0 ;
13432+ int res1 = 0 ;
13433+ double val2 ;
13434+ int ecode2 = 0 ;
13435+
13436+ if ((argc < 1) || (argc > 1)) {
13437+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13438+ }
13439+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13440+ if (!SWIG_IsOK(res1)) {
13441+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","se", 1, self ));
13442+ }
13443+ arg1 = (mrcImageInformation *)(argp1);
13444+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13445+ if (!SWIG_IsOK(ecode2)) {
13446+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","se", 2, argv[0] ));
13447+ }
13448+ arg2 = (double)(val2);
13449+ if (arg1) (arg1)->se = arg2;
13450+ return Qnil;
13451+fail:
13452+ return Qnil;
13453+}
13454+
13455+
13456+SWIGINTERN VALUE
13457+_wrap_mrcImageInformation_se_get(int argc, VALUE *argv, VALUE self) {
13458+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13459+ void *argp1 = 0 ;
13460+ int res1 = 0 ;
13461+ double result;
13462+ VALUE vresult = Qnil;
13463+
13464+ if ((argc < 0) || (argc > 0)) {
13465+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13466+ }
13467+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13468+ if (!SWIG_IsOK(res1)) {
13469+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","se", 1, self ));
13470+ }
13471+ arg1 = (mrcImageInformation *)(argp1);
13472+ result = (double) ((arg1)->se);
13473+ vresult = SWIG_From_double((double)(result));
13474+ return vresult;
13475+fail:
13476+ return Qnil;
13477+}
13478+
13479+
13480+SWIGINTERN VALUE
13481+_wrap_mrcImageInformation_rmax_set(int argc, VALUE *argv, VALUE self) {
13482+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13483+ double arg2 ;
13484+ void *argp1 = 0 ;
13485+ int res1 = 0 ;
13486+ double val2 ;
13487+ int ecode2 = 0 ;
13488+
13489+ if ((argc < 1) || (argc > 1)) {
13490+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13491+ }
13492+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13493+ if (!SWIG_IsOK(res1)) {
13494+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","rmax", 1, self ));
13495+ }
13496+ arg1 = (mrcImageInformation *)(argp1);
13497+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13498+ if (!SWIG_IsOK(ecode2)) {
13499+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","rmax", 2, argv[0] ));
13500+ }
13501+ arg2 = (double)(val2);
13502+ if (arg1) (arg1)->rmax = arg2;
13503+ return Qnil;
13504+fail:
13505+ return Qnil;
13506+}
13507+
13508+
13509+SWIGINTERN VALUE
13510+_wrap_mrcImageInformation_rmax_get(int argc, VALUE *argv, VALUE self) {
13511+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13512+ void *argp1 = 0 ;
13513+ int res1 = 0 ;
13514+ double result;
13515+ VALUE vresult = Qnil;
13516+
13517+ if ((argc < 0) || (argc > 0)) {
13518+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13519+ }
13520+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13521+ if (!SWIG_IsOK(res1)) {
13522+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","rmax", 1, self ));
13523+ }
13524+ arg1 = (mrcImageInformation *)(argp1);
13525+ result = (double) ((arg1)->rmax);
13526+ vresult = SWIG_From_double((double)(result));
13527+ return vresult;
13528+fail:
13529+ return Qnil;
13530+}
13531+
13532+
13533+SWIGINTERN VALUE
13534+_wrap_mrcImageInformation_flagrmax_set(int argc, VALUE *argv, VALUE self) {
13535+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13536+ long arg2 ;
13537+ void *argp1 = 0 ;
13538+ int res1 = 0 ;
13539+ long val2 ;
13540+ int ecode2 = 0 ;
13541+
13542+ if ((argc < 1) || (argc > 1)) {
13543+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13544+ }
13545+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13546+ if (!SWIG_IsOK(res1)) {
13547+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagrmax", 1, self ));
13548+ }
13549+ arg1 = (mrcImageInformation *)(argp1);
13550+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
13551+ if (!SWIG_IsOK(ecode2)) {
13552+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","flagrmax", 2, argv[0] ));
13553+ }
13554+ arg2 = (long)(val2);
13555+ if (arg1) (arg1)->flagrmax = arg2;
13556+ return Qnil;
13557+fail:
13558+ return Qnil;
13559+}
13560+
13561+
13562+SWIGINTERN VALUE
13563+_wrap_mrcImageInformation_flagrmax_get(int argc, VALUE *argv, VALUE self) {
13564+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13565+ void *argp1 = 0 ;
13566+ int res1 = 0 ;
13567+ long result;
13568+ VALUE vresult = Qnil;
13569+
13570+ if ((argc < 0) || (argc > 0)) {
13571+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13572+ }
13573+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13574+ if (!SWIG_IsOK(res1)) {
13575+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagrmax", 1, self ));
13576+ }
13577+ arg1 = (mrcImageInformation *)(argp1);
13578+ result = (long) ((arg1)->flagrmax);
13579+ vresult = SWIG_From_long((long)(result));
13580+ return vresult;
13581+fail:
13582+ return Qnil;
13583+}
13584+
13585+
13586+SWIGINTERN VALUE
13587+_wrap_mrcImageInformation_RMS_set(int argc, VALUE *argv, VALUE self) {
13588+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13589+ double arg2 ;
13590+ void *argp1 = 0 ;
13591+ int res1 = 0 ;
13592+ double val2 ;
13593+ int ecode2 = 0 ;
13594+
13595+ if ((argc < 1) || (argc > 1)) {
13596+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13597+ }
13598+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13599+ if (!SWIG_IsOK(res1)) {
13600+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","RMS", 1, self ));
13601+ }
13602+ arg1 = (mrcImageInformation *)(argp1);
13603+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13604+ if (!SWIG_IsOK(ecode2)) {
13605+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","RMS", 2, argv[0] ));
13606+ }
13607+ arg2 = (double)(val2);
13608+ if (arg1) (arg1)->RMS = arg2;
13609+ return Qnil;
13610+fail:
13611+ return Qnil;
13612+}
13613+
13614+
13615+SWIGINTERN VALUE
13616+_wrap_mrcImageInformation_RMS_get(int argc, VALUE *argv, VALUE self) {
13617+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13618+ void *argp1 = 0 ;
13619+ int res1 = 0 ;
13620+ double result;
13621+ VALUE vresult = Qnil;
13622+
13623+ if ((argc < 0) || (argc > 0)) {
13624+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13625+ }
13626+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13627+ if (!SWIG_IsOK(res1)) {
13628+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","RMS", 1, self ));
13629+ }
13630+ arg1 = (mrcImageInformation *)(argp1);
13631+ result = (double) ((arg1)->RMS);
13632+ vresult = SWIG_From_double((double)(result));
13633+ return vresult;
13634+fail:
13635+ return Qnil;
13636+}
13637+
13638+
13639+SWIGINTERN VALUE
13640+_wrap_mrcImageInformation_mode_set(int argc, VALUE *argv, VALUE self) {
13641+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13642+ int arg2 ;
13643+ void *argp1 = 0 ;
13644+ int res1 = 0 ;
13645+ int val2 ;
13646+ int ecode2 = 0 ;
13647+
13648+ if ((argc < 1) || (argc > 1)) {
13649+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13650+ }
13651+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13652+ if (!SWIG_IsOK(res1)) {
13653+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","mode", 1, self ));
13654+ }
13655+ arg1 = (mrcImageInformation *)(argp1);
13656+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
13657+ if (!SWIG_IsOK(ecode2)) {
13658+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","mode", 2, argv[0] ));
13659+ }
13660+ arg2 = (int)(val2);
13661+ if (arg1) (arg1)->mode = arg2;
13662+ return Qnil;
13663+fail:
13664+ return Qnil;
13665+}
13666+
13667+
13668+SWIGINTERN VALUE
13669+_wrap_mrcImageInformation_mode_get(int argc, VALUE *argv, VALUE self) {
13670+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13671+ void *argp1 = 0 ;
13672+ int res1 = 0 ;
13673+ int result;
13674+ VALUE vresult = Qnil;
13675+
13676+ if ((argc < 0) || (argc > 0)) {
13677+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13678+ }
13679+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13680+ if (!SWIG_IsOK(res1)) {
13681+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","mode", 1, self ));
13682+ }
13683+ arg1 = (mrcImageInformation *)(argp1);
13684+ result = (int) ((arg1)->mode);
13685+ vresult = SWIG_From_int((int)(result));
13686+ return vresult;
13687+fail:
13688+ return Qnil;
13689+}
13690+
13691+
13692+SWIGINTERN VALUE
13693+_wrap_mrcImageInformation_flagXrange_set(int argc, VALUE *argv, VALUE self) {
13694+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13695+ int arg2 ;
13696+ void *argp1 = 0 ;
13697+ int res1 = 0 ;
13698+ int val2 ;
13699+ int ecode2 = 0 ;
13700+
13701+ if ((argc < 1) || (argc > 1)) {
13702+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13703+ }
13704+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13705+ if (!SWIG_IsOK(res1)) {
13706+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagXrange", 1, self ));
13707+ }
13708+ arg1 = (mrcImageInformation *)(argp1);
13709+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
13710+ if (!SWIG_IsOK(ecode2)) {
13711+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","flagXrange", 2, argv[0] ));
13712+ }
13713+ arg2 = (int)(val2);
13714+ if (arg1) (arg1)->flagXrange = arg2;
13715+ return Qnil;
13716+fail:
13717+ return Qnil;
13718+}
13719+
13720+
13721+SWIGINTERN VALUE
13722+_wrap_mrcImageInformation_flagXrange_get(int argc, VALUE *argv, VALUE self) {
13723+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13724+ void *argp1 = 0 ;
13725+ int res1 = 0 ;
13726+ int result;
13727+ VALUE vresult = Qnil;
13728+
13729+ if ((argc < 0) || (argc > 0)) {
13730+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13731+ }
13732+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13733+ if (!SWIG_IsOK(res1)) {
13734+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagXrange", 1, self ));
13735+ }
13736+ arg1 = (mrcImageInformation *)(argp1);
13737+ result = (int) ((arg1)->flagXrange);
13738+ vresult = SWIG_From_int((int)(result));
13739+ return vresult;
13740+fail:
13741+ return Qnil;
13742+}
13743+
13744+
13745+SWIGINTERN VALUE
13746+_wrap_mrcImageInformation_flagYrange_set(int argc, VALUE *argv, VALUE self) {
13747+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13748+ int arg2 ;
13749+ void *argp1 = 0 ;
13750+ int res1 = 0 ;
13751+ int val2 ;
13752+ int ecode2 = 0 ;
13753+
13754+ if ((argc < 1) || (argc > 1)) {
13755+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13756+ }
13757+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13758+ if (!SWIG_IsOK(res1)) {
13759+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagYrange", 1, self ));
13760+ }
13761+ arg1 = (mrcImageInformation *)(argp1);
13762+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
13763+ if (!SWIG_IsOK(ecode2)) {
13764+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","flagYrange", 2, argv[0] ));
13765+ }
13766+ arg2 = (int)(val2);
13767+ if (arg1) (arg1)->flagYrange = arg2;
13768+ return Qnil;
13769+fail:
13770+ return Qnil;
13771+}
13772+
13773+
13774+SWIGINTERN VALUE
13775+_wrap_mrcImageInformation_flagYrange_get(int argc, VALUE *argv, VALUE self) {
13776+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13777+ void *argp1 = 0 ;
13778+ int res1 = 0 ;
13779+ int result;
13780+ VALUE vresult = Qnil;
13781+
13782+ if ((argc < 0) || (argc > 0)) {
13783+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13784+ }
13785+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13786+ if (!SWIG_IsOK(res1)) {
13787+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagYrange", 1, self ));
13788+ }
13789+ arg1 = (mrcImageInformation *)(argp1);
13790+ result = (int) ((arg1)->flagYrange);
13791+ vresult = SWIG_From_int((int)(result));
13792+ return vresult;
13793+fail:
13794+ return Qnil;
13795+}
13796+
13797+
13798+SWIGINTERN VALUE
13799+_wrap_mrcImageInformation_flagZrange_set(int argc, VALUE *argv, VALUE self) {
13800+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13801+ int arg2 ;
13802+ void *argp1 = 0 ;
13803+ int res1 = 0 ;
13804+ int val2 ;
13805+ int ecode2 = 0 ;
13806+
13807+ if ((argc < 1) || (argc > 1)) {
13808+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13809+ }
13810+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13811+ if (!SWIG_IsOK(res1)) {
13812+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagZrange", 1, self ));
13813+ }
13814+ arg1 = (mrcImageInformation *)(argp1);
13815+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
13816+ if (!SWIG_IsOK(ecode2)) {
13817+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","flagZrange", 2, argv[0] ));
13818+ }
13819+ arg2 = (int)(val2);
13820+ if (arg1) (arg1)->flagZrange = arg2;
13821+ return Qnil;
13822+fail:
13823+ return Qnil;
13824+}
13825+
13826+
13827+SWIGINTERN VALUE
13828+_wrap_mrcImageInformation_flagZrange_get(int argc, VALUE *argv, VALUE self) {
13829+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13830+ void *argp1 = 0 ;
13831+ int res1 = 0 ;
13832+ int result;
13833+ VALUE vresult = Qnil;
13834+
13835+ if ((argc < 0) || (argc > 0)) {
13836+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13837+ }
13838+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13839+ if (!SWIG_IsOK(res1)) {
13840+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagZrange", 1, self ));
13841+ }
13842+ arg1 = (mrcImageInformation *)(argp1);
13843+ result = (int) ((arg1)->flagZrange);
13844+ vresult = SWIG_From_int((int)(result));
13845+ return vresult;
13846+fail:
13847+ return Qnil;
13848+}
13849+
13850+
13851+SWIGINTERN VALUE
13852+_wrap_mrcImageInformation_XrangeMin_set(int argc, VALUE *argv, VALUE self) {
13853+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13854+ double arg2 ;
13855+ void *argp1 = 0 ;
13856+ int res1 = 0 ;
13857+ double val2 ;
13858+ int ecode2 = 0 ;
13859+
13860+ if ((argc < 1) || (argc > 1)) {
13861+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13862+ }
13863+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13864+ if (!SWIG_IsOK(res1)) {
13865+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","XrangeMin", 1, self ));
13866+ }
13867+ arg1 = (mrcImageInformation *)(argp1);
13868+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13869+ if (!SWIG_IsOK(ecode2)) {
13870+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","XrangeMin", 2, argv[0] ));
13871+ }
13872+ arg2 = (double)(val2);
13873+ if (arg1) (arg1)->XrangeMin = arg2;
13874+ return Qnil;
13875+fail:
13876+ return Qnil;
13877+}
13878+
13879+
13880+SWIGINTERN VALUE
13881+_wrap_mrcImageInformation_XrangeMin_get(int argc, VALUE *argv, VALUE self) {
13882+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13883+ void *argp1 = 0 ;
13884+ int res1 = 0 ;
13885+ double result;
13886+ VALUE vresult = Qnil;
13887+
13888+ if ((argc < 0) || (argc > 0)) {
13889+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13890+ }
13891+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13892+ if (!SWIG_IsOK(res1)) {
13893+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","XrangeMin", 1, self ));
13894+ }
13895+ arg1 = (mrcImageInformation *)(argp1);
13896+ result = (double) ((arg1)->XrangeMin);
13897+ vresult = SWIG_From_double((double)(result));
13898+ return vresult;
13899+fail:
13900+ return Qnil;
13901+}
13902+
13903+
13904+SWIGINTERN VALUE
13905+_wrap_mrcImageInformation_XrangeMax_set(int argc, VALUE *argv, VALUE self) {
13906+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13907+ double arg2 ;
13908+ void *argp1 = 0 ;
13909+ int res1 = 0 ;
13910+ double val2 ;
13911+ int ecode2 = 0 ;
13912+
13913+ if ((argc < 1) || (argc > 1)) {
13914+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13915+ }
13916+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13917+ if (!SWIG_IsOK(res1)) {
13918+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","XrangeMax", 1, self ));
13919+ }
13920+ arg1 = (mrcImageInformation *)(argp1);
13921+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13922+ if (!SWIG_IsOK(ecode2)) {
13923+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","XrangeMax", 2, argv[0] ));
13924+ }
13925+ arg2 = (double)(val2);
13926+ if (arg1) (arg1)->XrangeMax = arg2;
13927+ return Qnil;
13928+fail:
13929+ return Qnil;
13930+}
13931+
13932+
13933+SWIGINTERN VALUE
13934+_wrap_mrcImageInformation_XrangeMax_get(int argc, VALUE *argv, VALUE self) {
13935+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13936+ void *argp1 = 0 ;
13937+ int res1 = 0 ;
13938+ double result;
13939+ VALUE vresult = Qnil;
13940+
13941+ if ((argc < 0) || (argc > 0)) {
13942+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13943+ }
13944+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13945+ if (!SWIG_IsOK(res1)) {
13946+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","XrangeMax", 1, self ));
13947+ }
13948+ arg1 = (mrcImageInformation *)(argp1);
13949+ result = (double) ((arg1)->XrangeMax);
13950+ vresult = SWIG_From_double((double)(result));
13951+ return vresult;
13952+fail:
13953+ return Qnil;
13954+}
13955+
13956+
13957+SWIGINTERN VALUE
13958+_wrap_mrcImageInformation_YrangeMin_set(int argc, VALUE *argv, VALUE self) {
13959+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13960+ double arg2 ;
13961+ void *argp1 = 0 ;
13962+ int res1 = 0 ;
13963+ double val2 ;
13964+ int ecode2 = 0 ;
13965+
13966+ if ((argc < 1) || (argc > 1)) {
13967+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
13968+ }
13969+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13970+ if (!SWIG_IsOK(res1)) {
13971+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","YrangeMin", 1, self ));
13972+ }
13973+ arg1 = (mrcImageInformation *)(argp1);
13974+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
13975+ if (!SWIG_IsOK(ecode2)) {
13976+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","YrangeMin", 2, argv[0] ));
13977+ }
13978+ arg2 = (double)(val2);
13979+ if (arg1) (arg1)->YrangeMin = arg2;
13980+ return Qnil;
13981+fail:
13982+ return Qnil;
13983+}
13984+
13985+
13986+SWIGINTERN VALUE
13987+_wrap_mrcImageInformation_YrangeMin_get(int argc, VALUE *argv, VALUE self) {
13988+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
13989+ void *argp1 = 0 ;
13990+ int res1 = 0 ;
13991+ double result;
13992+ VALUE vresult = Qnil;
13993+
13994+ if ((argc < 0) || (argc > 0)) {
13995+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
13996+ }
13997+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
13998+ if (!SWIG_IsOK(res1)) {
13999+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","YrangeMin", 1, self ));
14000+ }
14001+ arg1 = (mrcImageInformation *)(argp1);
14002+ result = (double) ((arg1)->YrangeMin);
14003+ vresult = SWIG_From_double((double)(result));
14004+ return vresult;
14005+fail:
14006+ return Qnil;
14007+}
14008+
14009+
14010+SWIGINTERN VALUE
14011+_wrap_mrcImageInformation_YrangeMax_set(int argc, VALUE *argv, VALUE self) {
14012+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14013+ double arg2 ;
14014+ void *argp1 = 0 ;
14015+ int res1 = 0 ;
14016+ double val2 ;
14017+ int ecode2 = 0 ;
14018+
14019+ if ((argc < 1) || (argc > 1)) {
14020+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14021+ }
14022+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14023+ if (!SWIG_IsOK(res1)) {
14024+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","YrangeMax", 1, self ));
14025+ }
14026+ arg1 = (mrcImageInformation *)(argp1);
14027+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
14028+ if (!SWIG_IsOK(ecode2)) {
14029+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","YrangeMax", 2, argv[0] ));
14030+ }
14031+ arg2 = (double)(val2);
14032+ if (arg1) (arg1)->YrangeMax = arg2;
14033+ return Qnil;
14034+fail:
14035+ return Qnil;
14036+}
14037+
14038+
14039+SWIGINTERN VALUE
14040+_wrap_mrcImageInformation_YrangeMax_get(int argc, VALUE *argv, VALUE self) {
14041+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14042+ void *argp1 = 0 ;
14043+ int res1 = 0 ;
14044+ double result;
14045+ VALUE vresult = Qnil;
14046+
14047+ if ((argc < 0) || (argc > 0)) {
14048+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14049+ }
14050+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14051+ if (!SWIG_IsOK(res1)) {
14052+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","YrangeMax", 1, self ));
14053+ }
14054+ arg1 = (mrcImageInformation *)(argp1);
14055+ result = (double) ((arg1)->YrangeMax);
14056+ vresult = SWIG_From_double((double)(result));
14057+ return vresult;
14058+fail:
14059+ return Qnil;
14060+}
14061+
14062+
14063+SWIGINTERN VALUE
14064+_wrap_mrcImageInformation_ZrangeMin_set(int argc, VALUE *argv, VALUE self) {
14065+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14066+ double arg2 ;
14067+ void *argp1 = 0 ;
14068+ int res1 = 0 ;
14069+ double val2 ;
14070+ int ecode2 = 0 ;
14071+
14072+ if ((argc < 1) || (argc > 1)) {
14073+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14074+ }
14075+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14076+ if (!SWIG_IsOK(res1)) {
14077+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","ZrangeMin", 1, self ));
14078+ }
14079+ arg1 = (mrcImageInformation *)(argp1);
14080+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
14081+ if (!SWIG_IsOK(ecode2)) {
14082+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","ZrangeMin", 2, argv[0] ));
14083+ }
14084+ arg2 = (double)(val2);
14085+ if (arg1) (arg1)->ZrangeMin = arg2;
14086+ return Qnil;
14087+fail:
14088+ return Qnil;
14089+}
14090+
14091+
14092+SWIGINTERN VALUE
14093+_wrap_mrcImageInformation_ZrangeMin_get(int argc, VALUE *argv, VALUE self) {
14094+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14095+ void *argp1 = 0 ;
14096+ int res1 = 0 ;
14097+ double result;
14098+ VALUE vresult = Qnil;
14099+
14100+ if ((argc < 0) || (argc > 0)) {
14101+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14102+ }
14103+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14104+ if (!SWIG_IsOK(res1)) {
14105+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","ZrangeMin", 1, self ));
14106+ }
14107+ arg1 = (mrcImageInformation *)(argp1);
14108+ result = (double) ((arg1)->ZrangeMin);
14109+ vresult = SWIG_From_double((double)(result));
14110+ return vresult;
14111+fail:
14112+ return Qnil;
14113+}
14114+
14115+
14116+SWIGINTERN VALUE
14117+_wrap_mrcImageInformation_ZrangeMax_set(int argc, VALUE *argv, VALUE self) {
14118+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14119+ double arg2 ;
14120+ void *argp1 = 0 ;
14121+ int res1 = 0 ;
14122+ double val2 ;
14123+ int ecode2 = 0 ;
14124+
14125+ if ((argc < 1) || (argc > 1)) {
14126+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14127+ }
14128+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14129+ if (!SWIG_IsOK(res1)) {
14130+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","ZrangeMax", 1, self ));
14131+ }
14132+ arg1 = (mrcImageInformation *)(argp1);
14133+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
14134+ if (!SWIG_IsOK(ecode2)) {
14135+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","ZrangeMax", 2, argv[0] ));
14136+ }
14137+ arg2 = (double)(val2);
14138+ if (arg1) (arg1)->ZrangeMax = arg2;
14139+ return Qnil;
14140+fail:
14141+ return Qnil;
14142+}
14143+
14144+
14145+SWIGINTERN VALUE
14146+_wrap_mrcImageInformation_ZrangeMax_get(int argc, VALUE *argv, VALUE self) {
14147+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14148+ void *argp1 = 0 ;
14149+ int res1 = 0 ;
14150+ double result;
14151+ VALUE vresult = Qnil;
14152+
14153+ if ((argc < 0) || (argc > 0)) {
14154+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14155+ }
14156+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14157+ if (!SWIG_IsOK(res1)) {
14158+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","ZrangeMax", 1, self ));
14159+ }
14160+ arg1 = (mrcImageInformation *)(argp1);
14161+ result = (double) ((arg1)->ZrangeMax);
14162+ vresult = SWIG_From_double((double)(result));
14163+ return vresult;
14164+fail:
14165+ return Qnil;
14166+}
14167+
14168+
14169+SWIGINTERN VALUE
14170+_wrap_mrcImageInformation_flagCentre_set(int argc, VALUE *argv, VALUE self) {
14171+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14172+ int arg2 ;
14173+ void *argp1 = 0 ;
14174+ int res1 = 0 ;
14175+ int val2 ;
14176+ int ecode2 = 0 ;
14177+
14178+ if ((argc < 1) || (argc > 1)) {
14179+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14180+ }
14181+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14182+ if (!SWIG_IsOK(res1)) {
14183+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagCentre", 1, self ));
14184+ }
14185+ arg1 = (mrcImageInformation *)(argp1);
14186+ ecode2 = SWIG_AsVal_int(argv[0], &val2);
14187+ if (!SWIG_IsOK(ecode2)) {
14188+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","flagCentre", 2, argv[0] ));
14189+ }
14190+ arg2 = (int)(val2);
14191+ if (arg1) (arg1)->flagCentre = arg2;
14192+ return Qnil;
14193+fail:
14194+ return Qnil;
14195+}
14196+
14197+
14198+SWIGINTERN VALUE
14199+_wrap_mrcImageInformation_flagCentre_get(int argc, VALUE *argv, VALUE self) {
14200+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14201+ void *argp1 = 0 ;
14202+ int res1 = 0 ;
14203+ int result;
14204+ VALUE vresult = Qnil;
14205+
14206+ if ((argc < 0) || (argc > 0)) {
14207+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14208+ }
14209+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14210+ if (!SWIG_IsOK(res1)) {
14211+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","flagCentre", 1, self ));
14212+ }
14213+ arg1 = (mrcImageInformation *)(argp1);
14214+ result = (int) ((arg1)->flagCentre);
14215+ vresult = SWIG_From_int((int)(result));
14216+ return vresult;
14217+fail:
14218+ return Qnil;
14219+}
14220+
14221+
14222+SWIGINTERN VALUE
14223+_wrap_mrcImageInformation_CentreX_set(int argc, VALUE *argv, VALUE self) {
14224+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14225+ double arg2 ;
14226+ void *argp1 = 0 ;
14227+ int res1 = 0 ;
14228+ double val2 ;
14229+ int ecode2 = 0 ;
14230+
14231+ if ((argc < 1) || (argc > 1)) {
14232+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14233+ }
14234+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14235+ if (!SWIG_IsOK(res1)) {
14236+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","CentreX", 1, self ));
14237+ }
14238+ arg1 = (mrcImageInformation *)(argp1);
14239+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
14240+ if (!SWIG_IsOK(ecode2)) {
14241+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","CentreX", 2, argv[0] ));
14242+ }
14243+ arg2 = (double)(val2);
14244+ if (arg1) (arg1)->CentreX = arg2;
14245+ return Qnil;
14246+fail:
14247+ return Qnil;
14248+}
14249+
14250+
14251+SWIGINTERN VALUE
14252+_wrap_mrcImageInformation_CentreX_get(int argc, VALUE *argv, VALUE self) {
14253+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14254+ void *argp1 = 0 ;
14255+ int res1 = 0 ;
14256+ double result;
14257+ VALUE vresult = Qnil;
14258+
14259+ if ((argc < 0) || (argc > 0)) {
14260+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14261+ }
14262+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14263+ if (!SWIG_IsOK(res1)) {
14264+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","CentreX", 1, self ));
14265+ }
14266+ arg1 = (mrcImageInformation *)(argp1);
14267+ result = (double) ((arg1)->CentreX);
14268+ vresult = SWIG_From_double((double)(result));
14269+ return vresult;
14270+fail:
14271+ return Qnil;
14272+}
14273+
14274+
14275+SWIGINTERN VALUE
14276+_wrap_mrcImageInformation_CentreY_set(int argc, VALUE *argv, VALUE self) {
14277+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14278+ double arg2 ;
14279+ void *argp1 = 0 ;
14280+ int res1 = 0 ;
14281+ double val2 ;
14282+ int ecode2 = 0 ;
14283+
14284+ if ((argc < 1) || (argc > 1)) {
14285+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14286+ }
14287+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14288+ if (!SWIG_IsOK(res1)) {
14289+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","CentreY", 1, self ));
14290+ }
14291+ arg1 = (mrcImageInformation *)(argp1);
14292+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
14293+ if (!SWIG_IsOK(ecode2)) {
14294+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","CentreY", 2, argv[0] ));
14295+ }
14296+ arg2 = (double)(val2);
14297+ if (arg1) (arg1)->CentreY = arg2;
14298+ return Qnil;
14299+fail:
14300+ return Qnil;
14301+}
14302+
14303+
14304+SWIGINTERN VALUE
14305+_wrap_mrcImageInformation_CentreY_get(int argc, VALUE *argv, VALUE self) {
14306+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14307+ void *argp1 = 0 ;
14308+ int res1 = 0 ;
14309+ double result;
14310+ VALUE vresult = Qnil;
14311+
14312+ if ((argc < 0) || (argc > 0)) {
14313+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14314+ }
14315+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14316+ if (!SWIG_IsOK(res1)) {
14317+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","CentreY", 1, self ));
14318+ }
14319+ arg1 = (mrcImageInformation *)(argp1);
14320+ result = (double) ((arg1)->CentreY);
14321+ vresult = SWIG_From_double((double)(result));
14322+ return vresult;
14323+fail:
14324+ return Qnil;
14325+}
14326+
14327+
14328+SWIGINTERN VALUE
14329+_wrap_mrcImageInformation_CentreZ_set(int argc, VALUE *argv, VALUE self) {
14330+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14331+ double arg2 ;
14332+ void *argp1 = 0 ;
14333+ int res1 = 0 ;
14334+ double val2 ;
14335+ int ecode2 = 0 ;
14336+
14337+ if ((argc < 1) || (argc > 1)) {
14338+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14339+ }
14340+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14341+ if (!SWIG_IsOK(res1)) {
14342+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","CentreZ", 1, self ));
14343+ }
14344+ arg1 = (mrcImageInformation *)(argp1);
14345+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
14346+ if (!SWIG_IsOK(ecode2)) {
14347+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","CentreZ", 2, argv[0] ));
14348+ }
14349+ arg2 = (double)(val2);
14350+ if (arg1) (arg1)->CentreZ = arg2;
14351+ return Qnil;
14352+fail:
14353+ return Qnil;
14354+}
14355+
14356+
14357+SWIGINTERN VALUE
14358+_wrap_mrcImageInformation_CentreZ_get(int argc, VALUE *argv, VALUE self) {
14359+ mrcImageInformation *arg1 = (mrcImageInformation *) 0 ;
14360+ void *argp1 = 0 ;
14361+ int res1 = 0 ;
14362+ double result;
14363+ VALUE vresult = Qnil;
14364+
14365+ if ((argc < 0) || (argc > 0)) {
14366+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14367+ }
14368+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_mrcImageInformation, 0 | 0 );
14369+ if (!SWIG_IsOK(res1)) {
14370+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "mrcImageInformation *","CentreZ", 1, self ));
14371+ }
14372+ arg1 = (mrcImageInformation *)(argp1);
14373+ result = (double) ((arg1)->CentreZ);
14374+ vresult = SWIG_From_double((double)(result));
14375+ return vresult;
14376+fail:
14377+ return Qnil;
14378+}
14379+
14380+
14381+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
14382+SWIGINTERN VALUE
14383+_wrap_mrcImageInformation_allocate(VALUE self) {
14384+#else
14385+ SWIGINTERN VALUE
14386+ _wrap_mrcImageInformation_allocate(int argc, VALUE *argv, VALUE self) {
14387+#endif
14388+
14389+
14390+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_mrcImageInformation);
14391+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
14392+ rb_obj_call_init(vresult, argc, argv);
14393+#endif
14394+ return vresult;
14395+ }
14396+
14397+
14398+SWIGINTERN VALUE
14399+_wrap_new_mrcImageInformation(int argc, VALUE *argv, VALUE self) {
14400+ mrcImageInformation *result = 0 ;
14401+
14402+ if ((argc < 0) || (argc > 0)) {
14403+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14404+ }
14405+ result = (mrcImageInformation *)calloc(1, sizeof(mrcImageInformation));
14406+ DATA_PTR(self) = result;
14407+ return self;
14408+fail:
14409+ return Qnil;
14410+}
14411+
14412+
14413+SWIGINTERN void
14414+free_mrcImageInformation(mrcImageInformation *arg1) {
14415+ free((char *) arg1);
14416+}
14417+
14418+swig_class SwigClassLmrcImageSmoothingInfo;
14419+
14420+SWIGINTERN VALUE
14421+_wrap_lmrcImageSmoothingInfo_mode_set(int argc, VALUE *argv, VALUE self) {
14422+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14423+ long arg2 ;
14424+ void *argp1 = 0 ;
14425+ int res1 = 0 ;
14426+ long val2 ;
14427+ int ecode2 = 0 ;
14428+
14429+ if ((argc < 1) || (argc > 1)) {
14430+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14431+ }
14432+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14433+ if (!SWIG_IsOK(res1)) {
14434+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","mode", 1, self ));
14435+ }
14436+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14437+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
14438+ if (!SWIG_IsOK(ecode2)) {
14439+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","mode", 2, argv[0] ));
14440+ }
14441+ arg2 = (long)(val2);
14442+ if (arg1) (arg1)->mode = arg2;
14443+ return Qnil;
14444+fail:
14445+ return Qnil;
14446+}
14447+
14448+
14449+SWIGINTERN VALUE
14450+_wrap_lmrcImageSmoothingInfo_mode_get(int argc, VALUE *argv, VALUE self) {
14451+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14452+ void *argp1 = 0 ;
14453+ int res1 = 0 ;
14454+ long result;
14455+ VALUE vresult = Qnil;
14456+
14457+ if ((argc < 0) || (argc > 0)) {
14458+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14459+ }
14460+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14461+ if (!SWIG_IsOK(res1)) {
14462+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","mode", 1, self ));
14463+ }
14464+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14465+ result = (long) ((arg1)->mode);
14466+ vresult = SWIG_From_long((long)(result));
14467+ return vresult;
14468+fail:
14469+ return Qnil;
14470+}
14471+
14472+
14473+SWIGINTERN VALUE
14474+_wrap_lmrcImageSmoothingInfo_sx_set(int argc, VALUE *argv, VALUE self) {
14475+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14476+ mrcImageParaTypeReal arg2 ;
14477+ void *argp1 = 0 ;
14478+ int res1 = 0 ;
14479+ float val2 ;
14480+ int ecode2 = 0 ;
14481+
14482+ if ((argc < 1) || (argc > 1)) {
14483+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14484+ }
14485+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14486+ if (!SWIG_IsOK(res1)) {
14487+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","sx", 1, self ));
14488+ }
14489+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14490+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
14491+ if (!SWIG_IsOK(ecode2)) {
14492+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","sx", 2, argv[0] ));
14493+ }
14494+ arg2 = (mrcImageParaTypeReal)(val2);
14495+ if (arg1) (arg1)->sx = arg2;
14496+ return Qnil;
14497+fail:
14498+ return Qnil;
14499+}
14500+
14501+
14502+SWIGINTERN VALUE
14503+_wrap_lmrcImageSmoothingInfo_sx_get(int argc, VALUE *argv, VALUE self) {
14504+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14505+ void *argp1 = 0 ;
14506+ int res1 = 0 ;
14507+ mrcImageParaTypeReal result;
14508+ VALUE vresult = Qnil;
14509+
14510+ if ((argc < 0) || (argc > 0)) {
14511+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14512+ }
14513+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14514+ if (!SWIG_IsOK(res1)) {
14515+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","sx", 1, self ));
14516+ }
14517+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14518+ result = (mrcImageParaTypeReal) ((arg1)->sx);
14519+ vresult = SWIG_From_float((float)(result));
14520+ return vresult;
14521+fail:
14522+ return Qnil;
14523+}
14524+
14525+
14526+SWIGINTERN VALUE
14527+_wrap_lmrcImageSmoothingInfo_sy_set(int argc, VALUE *argv, VALUE self) {
14528+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14529+ mrcImageParaTypeReal arg2 ;
14530+ void *argp1 = 0 ;
14531+ int res1 = 0 ;
14532+ float val2 ;
14533+ int ecode2 = 0 ;
14534+
14535+ if ((argc < 1) || (argc > 1)) {
14536+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14537+ }
14538+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14539+ if (!SWIG_IsOK(res1)) {
14540+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","sy", 1, self ));
14541+ }
14542+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14543+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
14544+ if (!SWIG_IsOK(ecode2)) {
14545+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","sy", 2, argv[0] ));
14546+ }
14547+ arg2 = (mrcImageParaTypeReal)(val2);
14548+ if (arg1) (arg1)->sy = arg2;
14549+ return Qnil;
14550+fail:
14551+ return Qnil;
14552+}
14553+
14554+
14555+SWIGINTERN VALUE
14556+_wrap_lmrcImageSmoothingInfo_sy_get(int argc, VALUE *argv, VALUE self) {
14557+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14558+ void *argp1 = 0 ;
14559+ int res1 = 0 ;
14560+ mrcImageParaTypeReal result;
14561+ VALUE vresult = Qnil;
14562+
14563+ if ((argc < 0) || (argc > 0)) {
14564+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14565+ }
14566+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14567+ if (!SWIG_IsOK(res1)) {
14568+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","sy", 1, self ));
14569+ }
14570+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14571+ result = (mrcImageParaTypeReal) ((arg1)->sy);
14572+ vresult = SWIG_From_float((float)(result));
14573+ return vresult;
14574+fail:
14575+ return Qnil;
14576+}
14577+
14578+
14579+SWIGINTERN VALUE
14580+_wrap_lmrcImageSmoothingInfo_sz_set(int argc, VALUE *argv, VALUE self) {
14581+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14582+ mrcImageParaTypeReal arg2 ;
14583+ void *argp1 = 0 ;
14584+ int res1 = 0 ;
14585+ float val2 ;
14586+ int ecode2 = 0 ;
14587+
14588+ if ((argc < 1) || (argc > 1)) {
14589+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14590+ }
14591+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14592+ if (!SWIG_IsOK(res1)) {
14593+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","sz", 1, self ));
14594+ }
14595+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14596+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
14597+ if (!SWIG_IsOK(ecode2)) {
14598+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "mrcImageParaTypeReal","sz", 2, argv[0] ));
14599+ }
14600+ arg2 = (mrcImageParaTypeReal)(val2);
14601+ if (arg1) (arg1)->sz = arg2;
14602+ return Qnil;
14603+fail:
14604+ return Qnil;
14605+}
14606+
14607+
14608+SWIGINTERN VALUE
14609+_wrap_lmrcImageSmoothingInfo_sz_get(int argc, VALUE *argv, VALUE self) {
14610+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14611+ void *argp1 = 0 ;
14612+ int res1 = 0 ;
14613+ mrcImageParaTypeReal result;
14614+ VALUE vresult = Qnil;
14615+
14616+ if ((argc < 0) || (argc > 0)) {
14617+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14618+ }
14619+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14620+ if (!SWIG_IsOK(res1)) {
14621+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","sz", 1, self ));
14622+ }
14623+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14624+ result = (mrcImageParaTypeReal) ((arg1)->sz);
14625+ vresult = SWIG_From_float((float)(result));
14626+ return vresult;
14627+fail:
14628+ return Qnil;
14629+}
14630+
14631+
14632+SWIGINTERN VALUE
14633+_wrap_lmrcImageSmoothingInfo_sigma_set(int argc, VALUE *argv, VALUE self) {
14634+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14635+ double arg2 ;
14636+ void *argp1 = 0 ;
14637+ int res1 = 0 ;
14638+ double val2 ;
14639+ int ecode2 = 0 ;
14640+
14641+ if ((argc < 1) || (argc > 1)) {
14642+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14643+ }
14644+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14645+ if (!SWIG_IsOK(res1)) {
14646+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","sigma", 1, self ));
14647+ }
14648+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14649+ ecode2 = SWIG_AsVal_double(argv[0], &val2);
14650+ if (!SWIG_IsOK(ecode2)) {
14651+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "double","sigma", 2, argv[0] ));
14652+ }
14653+ arg2 = (double)(val2);
14654+ if (arg1) (arg1)->sigma = arg2;
14655+ return Qnil;
14656+fail:
14657+ return Qnil;
14658+}
14659+
14660+
14661+SWIGINTERN VALUE
14662+_wrap_lmrcImageSmoothingInfo_sigma_get(int argc, VALUE *argv, VALUE self) {
14663+ lmrcImageSmoothingInfo *arg1 = (lmrcImageSmoothingInfo *) 0 ;
14664+ void *argp1 = 0 ;
14665+ int res1 = 0 ;
14666+ double result;
14667+ VALUE vresult = Qnil;
14668+
14669+ if ((argc < 0) || (argc > 0)) {
14670+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14671+ }
14672+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageSmoothingInfo, 0 | 0 );
14673+ if (!SWIG_IsOK(res1)) {
14674+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageSmoothingInfo *","sigma", 1, self ));
14675+ }
14676+ arg1 = (lmrcImageSmoothingInfo *)(argp1);
14677+ result = (double) ((arg1)->sigma);
14678+ vresult = SWIG_From_double((double)(result));
14679+ return vresult;
14680+fail:
14681+ return Qnil;
14682+}
14683+
14684+
14685+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
14686+SWIGINTERN VALUE
14687+_wrap_lmrcImageSmoothingInfo_allocate(VALUE self) {
14688+#else
14689+ SWIGINTERN VALUE
14690+ _wrap_lmrcImageSmoothingInfo_allocate(int argc, VALUE *argv, VALUE self) {
14691+#endif
14692+
14693+
14694+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_lmrcImageSmoothingInfo);
14695+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
14696+ rb_obj_call_init(vresult, argc, argv);
14697+#endif
14698+ return vresult;
14699+ }
14700+
14701+
14702+SWIGINTERN VALUE
14703+_wrap_new_lmrcImageSmoothingInfo(int argc, VALUE *argv, VALUE self) {
14704+ lmrcImageSmoothingInfo *result = 0 ;
14705+
14706+ if ((argc < 0) || (argc > 0)) {
14707+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14708+ }
14709+ result = (lmrcImageSmoothingInfo *)calloc(1, sizeof(lmrcImageSmoothingInfo));
14710+ DATA_PTR(self) = result;
14711+ return self;
14712+fail:
14713+ return Qnil;
14714+}
14715+
14716+
14717+SWIGINTERN void
14718+free_lmrcImageSmoothingInfo(lmrcImageSmoothingInfo *arg1) {
14719+ free((char *) arg1);
14720+}
14721+
14722+swig_class SwigClassLmrcImageCVEInfo;
14723+
14724+SWIGINTERN VALUE
14725+_wrap_lmrcImageCVEInfo_sx_set(int argc, VALUE *argv, VALUE self) {
14726+ lmrcImageCVEInfo *arg1 = (lmrcImageCVEInfo *) 0 ;
14727+ long arg2 ;
14728+ void *argp1 = 0 ;
14729+ int res1 = 0 ;
14730+ long val2 ;
14731+ int ecode2 = 0 ;
14732+
14733+ if ((argc < 1) || (argc > 1)) {
14734+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14735+ }
14736+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageCVEInfo, 0 | 0 );
14737+ if (!SWIG_IsOK(res1)) {
14738+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageCVEInfo *","sx", 1, self ));
14739+ }
14740+ arg1 = (lmrcImageCVEInfo *)(argp1);
14741+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
14742+ if (!SWIG_IsOK(ecode2)) {
14743+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","sx", 2, argv[0] ));
14744+ }
14745+ arg2 = (long)(val2);
14746+ if (arg1) (arg1)->sx = arg2;
14747+ return Qnil;
14748+fail:
14749+ return Qnil;
14750+}
14751+
14752+
14753+SWIGINTERN VALUE
14754+_wrap_lmrcImageCVEInfo_sx_get(int argc, VALUE *argv, VALUE self) {
14755+ lmrcImageCVEInfo *arg1 = (lmrcImageCVEInfo *) 0 ;
14756+ void *argp1 = 0 ;
14757+ int res1 = 0 ;
14758+ long result;
14759+ VALUE vresult = Qnil;
14760+
14761+ if ((argc < 0) || (argc > 0)) {
14762+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14763+ }
14764+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageCVEInfo, 0 | 0 );
14765+ if (!SWIG_IsOK(res1)) {
14766+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageCVEInfo *","sx", 1, self ));
14767+ }
14768+ arg1 = (lmrcImageCVEInfo *)(argp1);
14769+ result = (long) ((arg1)->sx);
14770+ vresult = SWIG_From_long((long)(result));
14771+ return vresult;
14772+fail:
14773+ return Qnil;
14774+}
14775+
14776+
14777+SWIGINTERN VALUE
14778+_wrap_lmrcImageCVEInfo_sy_set(int argc, VALUE *argv, VALUE self) {
14779+ lmrcImageCVEInfo *arg1 = (lmrcImageCVEInfo *) 0 ;
14780+ long arg2 ;
14781+ void *argp1 = 0 ;
14782+ int res1 = 0 ;
14783+ long val2 ;
14784+ int ecode2 = 0 ;
14785+
14786+ if ((argc < 1) || (argc > 1)) {
14787+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14788+ }
14789+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageCVEInfo, 0 | 0 );
14790+ if (!SWIG_IsOK(res1)) {
14791+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageCVEInfo *","sy", 1, self ));
14792+ }
14793+ arg1 = (lmrcImageCVEInfo *)(argp1);
14794+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
14795+ if (!SWIG_IsOK(ecode2)) {
14796+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","sy", 2, argv[0] ));
14797+ }
14798+ arg2 = (long)(val2);
14799+ if (arg1) (arg1)->sy = arg2;
14800+ return Qnil;
14801+fail:
14802+ return Qnil;
14803+}
14804+
14805+
14806+SWIGINTERN VALUE
14807+_wrap_lmrcImageCVEInfo_sy_get(int argc, VALUE *argv, VALUE self) {
14808+ lmrcImageCVEInfo *arg1 = (lmrcImageCVEInfo *) 0 ;
14809+ void *argp1 = 0 ;
14810+ int res1 = 0 ;
14811+ long result;
14812+ VALUE vresult = Qnil;
14813+
14814+ if ((argc < 0) || (argc > 0)) {
14815+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14816+ }
14817+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageCVEInfo, 0 | 0 );
14818+ if (!SWIG_IsOK(res1)) {
14819+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageCVEInfo *","sy", 1, self ));
14820+ }
14821+ arg1 = (lmrcImageCVEInfo *)(argp1);
14822+ result = (long) ((arg1)->sy);
14823+ vresult = SWIG_From_long((long)(result));
14824+ return vresult;
14825+fail:
14826+ return Qnil;
14827+}
14828+
14829+
14830+SWIGINTERN VALUE
14831+_wrap_lmrcImageCVEInfo_sz_set(int argc, VALUE *argv, VALUE self) {
14832+ lmrcImageCVEInfo *arg1 = (lmrcImageCVEInfo *) 0 ;
14833+ long arg2 ;
14834+ void *argp1 = 0 ;
14835+ int res1 = 0 ;
14836+ long val2 ;
14837+ int ecode2 = 0 ;
14838+
14839+ if ((argc < 1) || (argc > 1)) {
14840+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14841+ }
14842+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageCVEInfo, 0 | 0 );
14843+ if (!SWIG_IsOK(res1)) {
14844+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageCVEInfo *","sz", 1, self ));
14845+ }
14846+ arg1 = (lmrcImageCVEInfo *)(argp1);
14847+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
14848+ if (!SWIG_IsOK(ecode2)) {
14849+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","sz", 2, argv[0] ));
14850+ }
14851+ arg2 = (long)(val2);
14852+ if (arg1) (arg1)->sz = arg2;
14853+ return Qnil;
14854+fail:
14855+ return Qnil;
14856+}
14857+
14858+
14859+SWIGINTERN VALUE
14860+_wrap_lmrcImageCVEInfo_sz_get(int argc, VALUE *argv, VALUE self) {
14861+ lmrcImageCVEInfo *arg1 = (lmrcImageCVEInfo *) 0 ;
14862+ void *argp1 = 0 ;
14863+ int res1 = 0 ;
14864+ long result;
14865+ VALUE vresult = Qnil;
14866+
14867+ if ((argc < 0) || (argc > 0)) {
14868+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14869+ }
14870+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageCVEInfo, 0 | 0 );
14871+ if (!SWIG_IsOK(res1)) {
14872+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageCVEInfo *","sz", 1, self ));
14873+ }
14874+ arg1 = (lmrcImageCVEInfo *)(argp1);
14875+ result = (long) ((arg1)->sz);
14876+ vresult = SWIG_From_long((long)(result));
14877+ return vresult;
14878+fail:
14879+ return Qnil;
14880+}
14881+
14882+
14883+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
14884+SWIGINTERN VALUE
14885+_wrap_lmrcImageCVEInfo_allocate(VALUE self) {
14886+#else
14887+ SWIGINTERN VALUE
14888+ _wrap_lmrcImageCVEInfo_allocate(int argc, VALUE *argv, VALUE self) {
14889+#endif
14890+
14891+
14892+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_lmrcImageCVEInfo);
14893+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
14894+ rb_obj_call_init(vresult, argc, argv);
14895+#endif
14896+ return vresult;
14897+ }
14898+
14899+
14900+SWIGINTERN VALUE
14901+_wrap_new_lmrcImageCVEInfo(int argc, VALUE *argv, VALUE self) {
14902+ lmrcImageCVEInfo *result = 0 ;
14903+
14904+ if ((argc < 0) || (argc > 0)) {
14905+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14906+ }
14907+ result = (lmrcImageCVEInfo *)calloc(1, sizeof(lmrcImageCVEInfo));
14908+ DATA_PTR(self) = result;
14909+ return self;
14910+fail:
14911+ return Qnil;
14912+}
14913+
14914+
14915+SWIGINTERN void
14916+free_lmrcImageCVEInfo(lmrcImageCVEInfo *arg1) {
14917+ free((char *) arg1);
14918+}
14919+
14920+swig_class SwigClassLmrcImageTfunctionInfo;
14921+
14922+SWIGINTERN VALUE
14923+_wrap_lmrcImageTfunctionInfo_sx_set(int argc, VALUE *argv, VALUE self) {
14924+ lmrcImageTfunctionInfo *arg1 = (lmrcImageTfunctionInfo *) 0 ;
14925+ long arg2 ;
14926+ void *argp1 = 0 ;
14927+ int res1 = 0 ;
14928+ long val2 ;
14929+ int ecode2 = 0 ;
14930+
14931+ if ((argc < 1) || (argc > 1)) {
14932+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14933+ }
14934+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageTfunctionInfo, 0 | 0 );
14935+ if (!SWIG_IsOK(res1)) {
14936+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageTfunctionInfo *","sx", 1, self ));
14937+ }
14938+ arg1 = (lmrcImageTfunctionInfo *)(argp1);
14939+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
14940+ if (!SWIG_IsOK(ecode2)) {
14941+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","sx", 2, argv[0] ));
14942+ }
14943+ arg2 = (long)(val2);
14944+ if (arg1) (arg1)->sx = arg2;
14945+ return Qnil;
14946+fail:
14947+ return Qnil;
14948+}
14949+
14950+
14951+SWIGINTERN VALUE
14952+_wrap_lmrcImageTfunctionInfo_sx_get(int argc, VALUE *argv, VALUE self) {
14953+ lmrcImageTfunctionInfo *arg1 = (lmrcImageTfunctionInfo *) 0 ;
14954+ void *argp1 = 0 ;
14955+ int res1 = 0 ;
14956+ long result;
14957+ VALUE vresult = Qnil;
14958+
14959+ if ((argc < 0) || (argc > 0)) {
14960+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
14961+ }
14962+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageTfunctionInfo, 0 | 0 );
14963+ if (!SWIG_IsOK(res1)) {
14964+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageTfunctionInfo *","sx", 1, self ));
14965+ }
14966+ arg1 = (lmrcImageTfunctionInfo *)(argp1);
14967+ result = (long) ((arg1)->sx);
14968+ vresult = SWIG_From_long((long)(result));
14969+ return vresult;
14970+fail:
14971+ return Qnil;
14972+}
14973+
14974+
14975+SWIGINTERN VALUE
14976+_wrap_lmrcImageTfunctionInfo_sy_set(int argc, VALUE *argv, VALUE self) {
14977+ lmrcImageTfunctionInfo *arg1 = (lmrcImageTfunctionInfo *) 0 ;
14978+ long arg2 ;
14979+ void *argp1 = 0 ;
14980+ int res1 = 0 ;
14981+ long val2 ;
14982+ int ecode2 = 0 ;
14983+
14984+ if ((argc < 1) || (argc > 1)) {
14985+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
14986+ }
14987+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageTfunctionInfo, 0 | 0 );
14988+ if (!SWIG_IsOK(res1)) {
14989+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageTfunctionInfo *","sy", 1, self ));
14990+ }
14991+ arg1 = (lmrcImageTfunctionInfo *)(argp1);
14992+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
14993+ if (!SWIG_IsOK(ecode2)) {
14994+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","sy", 2, argv[0] ));
14995+ }
14996+ arg2 = (long)(val2);
14997+ if (arg1) (arg1)->sy = arg2;
14998+ return Qnil;
14999+fail:
15000+ return Qnil;
15001+}
15002+
15003+
15004+SWIGINTERN VALUE
15005+_wrap_lmrcImageTfunctionInfo_sy_get(int argc, VALUE *argv, VALUE self) {
15006+ lmrcImageTfunctionInfo *arg1 = (lmrcImageTfunctionInfo *) 0 ;
15007+ void *argp1 = 0 ;
15008+ int res1 = 0 ;
15009+ long result;
15010+ VALUE vresult = Qnil;
15011+
15012+ if ((argc < 0) || (argc > 0)) {
15013+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15014+ }
15015+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageTfunctionInfo, 0 | 0 );
15016+ if (!SWIG_IsOK(res1)) {
15017+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageTfunctionInfo *","sy", 1, self ));
15018+ }
15019+ arg1 = (lmrcImageTfunctionInfo *)(argp1);
15020+ result = (long) ((arg1)->sy);
15021+ vresult = SWIG_From_long((long)(result));
15022+ return vresult;
15023+fail:
15024+ return Qnil;
15025+}
15026+
15027+
15028+SWIGINTERN VALUE
15029+_wrap_lmrcImageTfunctionInfo_sz_set(int argc, VALUE *argv, VALUE self) {
15030+ lmrcImageTfunctionInfo *arg1 = (lmrcImageTfunctionInfo *) 0 ;
15031+ long arg2 ;
15032+ void *argp1 = 0 ;
15033+ int res1 = 0 ;
15034+ long val2 ;
15035+ int ecode2 = 0 ;
15036+
15037+ if ((argc < 1) || (argc > 1)) {
15038+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15039+ }
15040+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageTfunctionInfo, 0 | 0 );
15041+ if (!SWIG_IsOK(res1)) {
15042+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageTfunctionInfo *","sz", 1, self ));
15043+ }
15044+ arg1 = (lmrcImageTfunctionInfo *)(argp1);
15045+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
15046+ if (!SWIG_IsOK(ecode2)) {
15047+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","sz", 2, argv[0] ));
15048+ }
15049+ arg2 = (long)(val2);
15050+ if (arg1) (arg1)->sz = arg2;
15051+ return Qnil;
15052+fail:
15053+ return Qnil;
15054+}
15055+
15056+
15057+SWIGINTERN VALUE
15058+_wrap_lmrcImageTfunctionInfo_sz_get(int argc, VALUE *argv, VALUE self) {
15059+ lmrcImageTfunctionInfo *arg1 = (lmrcImageTfunctionInfo *) 0 ;
15060+ void *argp1 = 0 ;
15061+ int res1 = 0 ;
15062+ long result;
15063+ VALUE vresult = Qnil;
15064+
15065+ if ((argc < 0) || (argc > 0)) {
15066+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15067+ }
15068+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageTfunctionInfo, 0 | 0 );
15069+ if (!SWIG_IsOK(res1)) {
15070+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageTfunctionInfo *","sz", 1, self ));
15071+ }
15072+ arg1 = (lmrcImageTfunctionInfo *)(argp1);
15073+ result = (long) ((arg1)->sz);
15074+ vresult = SWIG_From_long((long)(result));
15075+ return vresult;
15076+fail:
15077+ return Qnil;
15078+}
15079+
15080+
15081+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
15082+SWIGINTERN VALUE
15083+_wrap_lmrcImageTfunctionInfo_allocate(VALUE self) {
15084+#else
15085+ SWIGINTERN VALUE
15086+ _wrap_lmrcImageTfunctionInfo_allocate(int argc, VALUE *argv, VALUE self) {
15087+#endif
15088+
15089+
15090+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_lmrcImageTfunctionInfo);
15091+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
15092+ rb_obj_call_init(vresult, argc, argv);
15093+#endif
15094+ return vresult;
15095+ }
15096+
15097+
15098+SWIGINTERN VALUE
15099+_wrap_new_lmrcImageTfunctionInfo(int argc, VALUE *argv, VALUE self) {
15100+ lmrcImageTfunctionInfo *result = 0 ;
15101+
15102+ if ((argc < 0) || (argc > 0)) {
15103+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15104+ }
15105+ result = (lmrcImageTfunctionInfo *)calloc(1, sizeof(lmrcImageTfunctionInfo));
15106+ DATA_PTR(self) = result;
15107+ return self;
15108+fail:
15109+ return Qnil;
15110+}
15111+
15112+
15113+SWIGINTERN void
15114+free_lmrcImageTfunctionInfo(lmrcImageTfunctionInfo *arg1) {
15115+ free((char *) arg1);
15116+}
15117+
15118+swig_class SwigClassLmrcImageHighlightInfo;
15119+
15120+SWIGINTERN VALUE
15121+_wrap_lmrcImageHighlightInfo_mode_set(int argc, VALUE *argv, VALUE self) {
15122+ lmrcImageHighlightInfo *arg1 = (lmrcImageHighlightInfo *) 0 ;
15123+ long arg2 ;
15124+ void *argp1 = 0 ;
15125+ int res1 = 0 ;
15126+ long val2 ;
15127+ int ecode2 = 0 ;
15128+
15129+ if ((argc < 1) || (argc > 1)) {
15130+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15131+ }
15132+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageHighlightInfo, 0 | 0 );
15133+ if (!SWIG_IsOK(res1)) {
15134+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageHighlightInfo *","mode", 1, self ));
15135+ }
15136+ arg1 = (lmrcImageHighlightInfo *)(argp1);
15137+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
15138+ if (!SWIG_IsOK(ecode2)) {
15139+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","mode", 2, argv[0] ));
15140+ }
15141+ arg2 = (long)(val2);
15142+ if (arg1) (arg1)->mode = arg2;
15143+ return Qnil;
15144+fail:
15145+ return Qnil;
15146+}
15147+
15148+
15149+SWIGINTERN VALUE
15150+_wrap_lmrcImageHighlightInfo_mode_get(int argc, VALUE *argv, VALUE self) {
15151+ lmrcImageHighlightInfo *arg1 = (lmrcImageHighlightInfo *) 0 ;
15152+ void *argp1 = 0 ;
15153+ int res1 = 0 ;
15154+ long result;
15155+ VALUE vresult = Qnil;
15156+
15157+ if ((argc < 0) || (argc > 0)) {
15158+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15159+ }
15160+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageHighlightInfo, 0 | 0 );
15161+ if (!SWIG_IsOK(res1)) {
15162+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageHighlightInfo *","mode", 1, self ));
15163+ }
15164+ arg1 = (lmrcImageHighlightInfo *)(argp1);
15165+ result = (long) ((arg1)->mode);
15166+ vresult = SWIG_From_long((long)(result));
15167+ return vresult;
15168+fail:
15169+ return Qnil;
15170+}
15171+
15172+
15173+SWIGINTERN VALUE
15174+_wrap_lmrcImageHighlightInfo_Bias_set(int argc, VALUE *argv, VALUE self) {
15175+ lmrcImageHighlightInfo *arg1 = (lmrcImageHighlightInfo *) 0 ;
15176+ float arg2 ;
15177+ void *argp1 = 0 ;
15178+ int res1 = 0 ;
15179+ float val2 ;
15180+ int ecode2 = 0 ;
15181+
15182+ if ((argc < 1) || (argc > 1)) {
15183+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15184+ }
15185+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageHighlightInfo, 0 | 0 );
15186+ if (!SWIG_IsOK(res1)) {
15187+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageHighlightInfo *","Bias", 1, self ));
15188+ }
15189+ arg1 = (lmrcImageHighlightInfo *)(argp1);
15190+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
15191+ if (!SWIG_IsOK(ecode2)) {
15192+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","Bias", 2, argv[0] ));
15193+ }
15194+ arg2 = (float)(val2);
15195+ if (arg1) (arg1)->Bias = arg2;
15196+ return Qnil;
15197+fail:
15198+ return Qnil;
15199+}
15200+
15201+
15202+SWIGINTERN VALUE
15203+_wrap_lmrcImageHighlightInfo_Bias_get(int argc, VALUE *argv, VALUE self) {
15204+ lmrcImageHighlightInfo *arg1 = (lmrcImageHighlightInfo *) 0 ;
15205+ void *argp1 = 0 ;
15206+ int res1 = 0 ;
15207+ float result;
15208+ VALUE vresult = Qnil;
15209+
15210+ if ((argc < 0) || (argc > 0)) {
15211+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15212+ }
15213+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageHighlightInfo, 0 | 0 );
15214+ if (!SWIG_IsOK(res1)) {
15215+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageHighlightInfo *","Bias", 1, self ));
15216+ }
15217+ arg1 = (lmrcImageHighlightInfo *)(argp1);
15218+ result = (float) ((arg1)->Bias);
15219+ vresult = SWIG_From_float((float)(result));
15220+ return vresult;
15221+fail:
15222+ return Qnil;
15223+}
15224+
15225+
15226+SWIGINTERN VALUE
15227+_wrap_lmrcImageHighlightInfo_Grad_set(int argc, VALUE *argv, VALUE self) {
15228+ lmrcImageHighlightInfo *arg1 = (lmrcImageHighlightInfo *) 0 ;
15229+ float arg2 ;
15230+ void *argp1 = 0 ;
15231+ int res1 = 0 ;
15232+ float val2 ;
15233+ int ecode2 = 0 ;
15234+
15235+ if ((argc < 1) || (argc > 1)) {
15236+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15237+ }
15238+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageHighlightInfo, 0 | 0 );
15239+ if (!SWIG_IsOK(res1)) {
15240+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageHighlightInfo *","Grad", 1, self ));
15241+ }
15242+ arg1 = (lmrcImageHighlightInfo *)(argp1);
15243+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
15244+ if (!SWIG_IsOK(ecode2)) {
15245+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","Grad", 2, argv[0] ));
15246+ }
15247+ arg2 = (float)(val2);
15248+ if (arg1) (arg1)->Grad = arg2;
15249+ return Qnil;
15250+fail:
15251+ return Qnil;
15252+}
15253+
15254+
15255+SWIGINTERN VALUE
15256+_wrap_lmrcImageHighlightInfo_Grad_get(int argc, VALUE *argv, VALUE self) {
15257+ lmrcImageHighlightInfo *arg1 = (lmrcImageHighlightInfo *) 0 ;
15258+ void *argp1 = 0 ;
15259+ int res1 = 0 ;
15260+ float result;
15261+ VALUE vresult = Qnil;
15262+
15263+ if ((argc < 0) || (argc > 0)) {
15264+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15265+ }
15266+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageHighlightInfo, 0 | 0 );
15267+ if (!SWIG_IsOK(res1)) {
15268+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageHighlightInfo *","Grad", 1, self ));
15269+ }
15270+ arg1 = (lmrcImageHighlightInfo *)(argp1);
15271+ result = (float) ((arg1)->Grad);
15272+ vresult = SWIG_From_float((float)(result));
15273+ return vresult;
15274+fail:
15275+ return Qnil;
15276+}
15277+
15278+
15279+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
15280+SWIGINTERN VALUE
15281+_wrap_lmrcImageHighlightInfo_allocate(VALUE self) {
15282+#else
15283+ SWIGINTERN VALUE
15284+ _wrap_lmrcImageHighlightInfo_allocate(int argc, VALUE *argv, VALUE self) {
15285+#endif
15286+
15287+
15288+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_lmrcImageHighlightInfo);
15289+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
15290+ rb_obj_call_init(vresult, argc, argv);
15291+#endif
15292+ return vresult;
15293+ }
15294+
15295+
15296+SWIGINTERN VALUE
15297+_wrap_new_lmrcImageHighlightInfo(int argc, VALUE *argv, VALUE self) {
15298+ lmrcImageHighlightInfo *result = 0 ;
15299+
15300+ if ((argc < 0) || (argc > 0)) {
15301+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15302+ }
15303+ result = (lmrcImageHighlightInfo *)calloc(1, sizeof(lmrcImageHighlightInfo));
15304+ DATA_PTR(self) = result;
15305+ return self;
15306+fail:
15307+ return Qnil;
15308+}
15309+
15310+
15311+SWIGINTERN void
15312+free_lmrcImageHighlightInfo(lmrcImageHighlightInfo *arg1) {
15313+ free((char *) arg1);
15314+}
15315+
15316+swig_class SwigClassLmrcImageLowPassFilterInfo;
15317+
15318+SWIGINTERN VALUE
15319+_wrap_lmrcImageLowPassFilterInfo_mode_set(int argc, VALUE *argv, VALUE self) {
15320+ lmrcImageLowPassFilterInfo *arg1 = (lmrcImageLowPassFilterInfo *) 0 ;
15321+ long arg2 ;
15322+ void *argp1 = 0 ;
15323+ int res1 = 0 ;
15324+ long val2 ;
15325+ int ecode2 = 0 ;
15326+
15327+ if ((argc < 1) || (argc > 1)) {
15328+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15329+ }
15330+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageLowPassFilterInfo, 0 | 0 );
15331+ if (!SWIG_IsOK(res1)) {
15332+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageLowPassFilterInfo *","mode", 1, self ));
15333+ }
15334+ arg1 = (lmrcImageLowPassFilterInfo *)(argp1);
15335+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
15336+ if (!SWIG_IsOK(ecode2)) {
15337+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","mode", 2, argv[0] ));
15338+ }
15339+ arg2 = (long)(val2);
15340+ if (arg1) (arg1)->mode = arg2;
15341+ return Qnil;
15342+fail:
15343+ return Qnil;
15344+}
15345+
15346+
15347+SWIGINTERN VALUE
15348+_wrap_lmrcImageLowPassFilterInfo_mode_get(int argc, VALUE *argv, VALUE self) {
15349+ lmrcImageLowPassFilterInfo *arg1 = (lmrcImageLowPassFilterInfo *) 0 ;
15350+ void *argp1 = 0 ;
15351+ int res1 = 0 ;
15352+ long result;
15353+ VALUE vresult = Qnil;
15354+
15355+ if ((argc < 0) || (argc > 0)) {
15356+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15357+ }
15358+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageLowPassFilterInfo, 0 | 0 );
15359+ if (!SWIG_IsOK(res1)) {
15360+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageLowPassFilterInfo *","mode", 1, self ));
15361+ }
15362+ arg1 = (lmrcImageLowPassFilterInfo *)(argp1);
15363+ result = (long) ((arg1)->mode);
15364+ vresult = SWIG_From_long((long)(result));
15365+ return vresult;
15366+fail:
15367+ return Qnil;
15368+}
15369+
15370+
15371+SWIGINTERN VALUE
15372+_wrap_lmrcImageLowPassFilterInfo_hvp_set(int argc, VALUE *argv, VALUE self) {
15373+ lmrcImageLowPassFilterInfo *arg1 = (lmrcImageLowPassFilterInfo *) 0 ;
15374+ float arg2 ;
15375+ void *argp1 = 0 ;
15376+ int res1 = 0 ;
15377+ float val2 ;
15378+ int ecode2 = 0 ;
15379+
15380+ if ((argc < 1) || (argc > 1)) {
15381+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15382+ }
15383+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageLowPassFilterInfo, 0 | 0 );
15384+ if (!SWIG_IsOK(res1)) {
15385+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageLowPassFilterInfo *","hvp", 1, self ));
15386+ }
15387+ arg1 = (lmrcImageLowPassFilterInfo *)(argp1);
15388+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
15389+ if (!SWIG_IsOK(ecode2)) {
15390+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","hvp", 2, argv[0] ));
15391+ }
15392+ arg2 = (float)(val2);
15393+ if (arg1) (arg1)->hvp = arg2;
15394+ return Qnil;
15395+fail:
15396+ return Qnil;
15397+}
15398+
15399+
15400+SWIGINTERN VALUE
15401+_wrap_lmrcImageLowPassFilterInfo_hvp_get(int argc, VALUE *argv, VALUE self) {
15402+ lmrcImageLowPassFilterInfo *arg1 = (lmrcImageLowPassFilterInfo *) 0 ;
15403+ void *argp1 = 0 ;
15404+ int res1 = 0 ;
15405+ float result;
15406+ VALUE vresult = Qnil;
15407+
15408+ if ((argc < 0) || (argc > 0)) {
15409+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15410+ }
15411+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageLowPassFilterInfo, 0 | 0 );
15412+ if (!SWIG_IsOK(res1)) {
15413+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageLowPassFilterInfo *","hvp", 1, self ));
15414+ }
15415+ arg1 = (lmrcImageLowPassFilterInfo *)(argp1);
15416+ result = (float) ((arg1)->hvp);
15417+ vresult = SWIG_From_float((float)(result));
15418+ return vresult;
15419+fail:
15420+ return Qnil;
15421+}
15422+
15423+
15424+SWIGINTERN VALUE
15425+_wrap_lmrcImageLowPassFilterInfo_width_set(int argc, VALUE *argv, VALUE self) {
15426+ lmrcImageLowPassFilterInfo *arg1 = (lmrcImageLowPassFilterInfo *) 0 ;
15427+ float arg2 ;
15428+ void *argp1 = 0 ;
15429+ int res1 = 0 ;
15430+ float val2 ;
15431+ int ecode2 = 0 ;
15432+
15433+ if ((argc < 1) || (argc > 1)) {
15434+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15435+ }
15436+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageLowPassFilterInfo, 0 | 0 );
15437+ if (!SWIG_IsOK(res1)) {
15438+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageLowPassFilterInfo *","width", 1, self ));
15439+ }
15440+ arg1 = (lmrcImageLowPassFilterInfo *)(argp1);
15441+ ecode2 = SWIG_AsVal_float(argv[0], &val2);
15442+ if (!SWIG_IsOK(ecode2)) {
15443+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","width", 2, argv[0] ));
15444+ }
15445+ arg2 = (float)(val2);
15446+ if (arg1) (arg1)->width = arg2;
15447+ return Qnil;
15448+fail:
15449+ return Qnil;
15450+}
15451+
15452+
15453+SWIGINTERN VALUE
15454+_wrap_lmrcImageLowPassFilterInfo_width_get(int argc, VALUE *argv, VALUE self) {
15455+ lmrcImageLowPassFilterInfo *arg1 = (lmrcImageLowPassFilterInfo *) 0 ;
15456+ void *argp1 = 0 ;
15457+ int res1 = 0 ;
15458+ float result;
15459+ VALUE vresult = Qnil;
15460+
15461+ if ((argc < 0) || (argc > 0)) {
15462+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15463+ }
15464+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageLowPassFilterInfo, 0 | 0 );
15465+ if (!SWIG_IsOK(res1)) {
15466+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageLowPassFilterInfo *","width", 1, self ));
15467+ }
15468+ arg1 = (lmrcImageLowPassFilterInfo *)(argp1);
15469+ result = (float) ((arg1)->width);
15470+ vresult = SWIG_From_float((float)(result));
15471+ return vresult;
15472+fail:
15473+ return Qnil;
15474+}
15475+
15476+
15477+#ifdef HAVE_RB_DEFINE_ALLOC_FUNC
15478+SWIGINTERN VALUE
15479+_wrap_lmrcImageLowPassFilterInfo_allocate(VALUE self) {
15480+#else
15481+ SWIGINTERN VALUE
15482+ _wrap_lmrcImageLowPassFilterInfo_allocate(int argc, VALUE *argv, VALUE self) {
15483+#endif
15484+
15485+
15486+ VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_lmrcImageLowPassFilterInfo);
15487+#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
15488+ rb_obj_call_init(vresult, argc, argv);
15489+#endif
15490+ return vresult;
15491+ }
15492+
15493+
15494+SWIGINTERN VALUE
15495+_wrap_new_lmrcImageLowPassFilterInfo(int argc, VALUE *argv, VALUE self) {
15496+ lmrcImageLowPassFilterInfo *result = 0 ;
15497+
15498+ if ((argc < 0) || (argc > 0)) {
15499+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15500+ }
15501+ result = (lmrcImageLowPassFilterInfo *)calloc(1, sizeof(lmrcImageLowPassFilterInfo));
15502+ DATA_PTR(self) = result;
15503+ return self;
15504+fail:
15505+ return Qnil;
15506+}
15507+
15508+
15509+SWIGINTERN void
15510+free_lmrcImageLowPassFilterInfo(lmrcImageLowPassFilterInfo *arg1) {
15511+ free((char *) arg1);
15512+}
15513+
15514+swig_class SwigClassLmrcImageHighPassFilterInfo;
15515+
15516+SWIGINTERN VALUE
15517+_wrap_lmrcImageHighPassFilterInfo_mode_set(int argc, VALUE *argv, VALUE self) {
15518+ lmrcImageHighPassFilterInfo *arg1 = (lmrcImageHighPassFilterInfo *) 0 ;
15519+ long arg2 ;
15520+ void *argp1 = 0 ;
15521+ int res1 = 0 ;
15522+ long val2 ;
15523+ int ecode2 = 0 ;
15524+
15525+ if ((argc < 1) || (argc > 1)) {
15526+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
15527+ }
15528+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageHighPassFilterInfo, 0 | 0 );
15529+ if (!SWIG_IsOK(res1)) {
15530+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageHighPassFilterInfo *","mode", 1, self ));
15531+ }
15532+ arg1 = (lmrcImageHighPassFilterInfo *)(argp1);
15533+ ecode2 = SWIG_AsVal_long(argv[0], &val2);
15534+ if (!SWIG_IsOK(ecode2)) {
15535+ SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","mode", 2, argv[0] ));
15536+ }
15537+ arg2 = (long)(val2);
15538+ if (arg1) (arg1)->mode = arg2;
15539+ return Qnil;
15540+fail:
15541+ return Qnil;
15542+}
15543+
15544+
15545+SWIGINTERN VALUE
15546+_wrap_lmrcImageHighPassFilterInfo_mode_get(int argc, VALUE *argv, VALUE self) {
15547+ lmrcImageHighPassFilterInfo *arg1 = (lmrcImageHighPassFilterInfo *) 0 ;
15548+ void *argp1 = 0 ;
15549+ int res1 = 0 ;
15550+ long result;
15551+ VALUE vresult = Qnil;
15552+
15553+ if ((argc < 0) || (argc > 0)) {
15554+ rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
15555+ }
15556+ res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_lmrcImageHighPassFilterInfo, 0 | 0 );
15557+ if (!SWIG_IsOK(res1)) {
15558+ SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "lmrcImageHighPassFilterInfo *","mode", 1, self ));
15559+ }
15560+ arg1 =

Part of diff was cut off due to size limit. Use your local client to view the full diff.

Show on old repository browser