1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
|
#-----------------------------------------------------------------------
#Copyright 2013 Centrum Wiskunde & Informatica, Amsterdam
#
#Author: Daniel M. Pelt
#Contact: D.M.Pelt@cwi.nl
#Website: http://dmpelt.github.io/pyastratoolbox/
#
#
#This file is part of the Python interface to the
#All Scale Tomographic Reconstruction Antwerp Toolbox ("ASTRA Toolbox").
#
#The Python interface to the ASTRA Toolbox is free software: you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation, either version 3 of the License, or
#(at your option) any later version.
#
#The Python interface to the ASTRA Toolbox is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#GNU General Public License for more details.
#
#You should have received a copy of the GNU General Public License
#along with the Python interface to the ASTRA Toolbox. If not, see <http://www.gnu.org/licenses/>.
#
#-----------------------------------------------------------------------
# distutils: language = c++
# distutils: libraries = astra
import six
cimport cython
cimport PyData3DManager
from .PyData3DManager cimport CData3DManager
from .PyIncludes cimport *
import numpy as np
cimport numpy as np
np.import_array()
cimport PyXMLDocument
from .PyXMLDocument cimport XMLDocument
cimport utils
from .utils import wrap_from_bytes
cdef CData3DManager * man3d = <CData3DManager * >PyData3DManager.getSingletonPtr()
cdef extern from *:
CFloat32Data3DMemory * dynamic_cast_mem "dynamic_cast<astra::CFloat32Data3DMemory*>" (CFloat32Data3D * ) except NULL
def create(datatype,geometry,data=None):
cdef Config *cfg
cdef CVolumeGeometry3D * pGeometry
cdef CProjectionGeometry3D * ppGeometry
cdef CFloat32Data3DMemory * pDataObject3D
cdef CConeProjectionGeometry3D* pppGeometry
if datatype == '-vol':
cfg = utils.dictToConfig(six.b('VolumeGeometry'), geometry)
pGeometry = new CVolumeGeometry3D()
if not pGeometry.initialize(cfg[0]):
del cfg
del pGeometry
raise Exception('Geometry class not initialized.')
pDataObject3D = <CFloat32Data3DMemory * > new CFloat32VolumeData3DMemory(pGeometry)
del cfg
del pGeometry
elif datatype == '-sino' or datatype == '-proj3d':
cfg = utils.dictToConfig(six.b('ProjectionGeometry'), geometry)
tpe = wrap_from_bytes(cfg.self.getAttribute(six.b('type')))
if (tpe == "parallel3d"):
ppGeometry = <CProjectionGeometry3D*> new CParallelProjectionGeometry3D();
elif (tpe == "parallel3d_vec"):
ppGeometry = <CProjectionGeometry3D*> new CParallelVecProjectionGeometry3D();
elif (tpe == "cone"):
ppGeometry = <CProjectionGeometry3D*> new CConeProjectionGeometry3D();
elif (tpe == "cone_vec"):
ppGeometry = <CProjectionGeometry3D*> new CConeVecProjectionGeometry3D();
else:
raise Exception("Invalid geometry type.")
if not ppGeometry.initialize(cfg[0]):
del cfg
del ppGeometry
raise Exception('Geometry class not initialized.')
pDataObject3D = <CFloat32Data3DMemory * > new CFloat32ProjectionData3DMemory(ppGeometry)
del ppGeometry
del cfg
elif datatype == "-sinocone":
cfg = utils.dictToConfig(six.b('ProjectionGeometry'), geometry)
pppGeometry = new CConeProjectionGeometry3D()
if not pppGeometry.initialize(cfg[0]):
del cfg
del pppGeometry
raise Exception('Geometry class not initialized.')
pDataObject3D = <CFloat32Data3DMemory * > new CFloat32ProjectionData3DMemory(pppGeometry)
else:
raise Exception("Invalid datatype. Please specify '-vol' or '-proj3d'.")
if not pDataObject3D.isInitialized():
del pDataObject3D
raise Exception("Couldn't initialize data object.")
fillDataObject(pDataObject3D, data)
pDataObject3D.updateStatistics()
return man3d.store(<CFloat32Data3D*>pDataObject3D)
def get_geometry(i):
cdef CFloat32Data3DMemory * pDataObject = dynamic_cast_mem(getObject(i))
cdef CFloat32ProjectionData3DMemory * pDataObject2
cdef CFloat32VolumeData3DMemory * pDataObject3
if pDataObject.getType() == THREEPROJECTION:
pDataObject2 = <CFloat32ProjectionData3DMemory * >pDataObject
geom = utils.configToDict(pDataObject2.getGeometry().getConfiguration())
elif pDataObject.getType() == THREEVOLUME:
pDataObject3 = <CFloat32VolumeData3DMemory * >pDataObject
geom = utils.configToDict(pDataObject3.getGeometry().getConfiguration())
else:
raise Exception("Not a known data object")
return geom
def change_geometry(i, geom):
cdef CFloat32Data3DMemory * pDataObject = dynamic_cast_mem(getObject(i))
cdef CFloat32ProjectionData3DMemory * pDataObject2
cdef CFloat32VolumeData3DMemory * pDataObject3
if pDataObject.getType() == THREEPROJECTION:
pDataObject2 = <CFloat32ProjectionData3DMemory * >pDataObject
# TODO: Reduce code duplication here
cfg = utils.dictToConfig(six.b('ProjectionGeometry'), geom)
tpe = wrap_from_bytes(cfg.self.getAttribute(six.b('type')))
if (tpe == "parallel3d"):
ppGeometry = <CProjectionGeometry3D*> new CParallelProjectionGeometry3D();
elif (tpe == "parallel3d_vec"):
ppGeometry = <CProjectionGeometry3D*> new CParallelVecProjectionGeometry3D();
elif (tpe == "cone"):
ppGeometry = <CProjectionGeometry3D*> new CConeProjectionGeometry3D();
elif (tpe == "cone_vec"):
ppGeometry = <CProjectionGeometry3D*> new CConeVecProjectionGeometry3D();
else:
raise Exception("Invalid geometry type.")
if not ppGeometry.initialize(cfg[0]):
del cfg
del ppGeometry
raise Exception('Geometry class not initialized.')
del cfg
if (ppGeometry.getDetectorColCount() != pDataObject2.getDetectorColCount() or \
ppGeometry.getProjectionCount() != pDataObject2.getAngleCount() or \
ppGeometry.getDetectorRowCount() != pDataObject2.getDetectorRowCount()):
del ppGeometry
raise Exception(
"The dimensions of the data do not match those specified in the geometry.")
pDataObject2.changeGeometry(ppGeometry)
del ppGeometry
elif pDataObject.getType() == THREEVOLUME:
pDataObject3 = <CFloat32VolumeData3DMemory * >pDataObject
cfg = utils.dictToConfig(six.b('VolumeGeometry'), geom)
pGeometry = new CVolumeGeometry3D()
if not pGeometry.initialize(cfg[0]):
del cfg
del pGeometry
raise Exception('Geometry class not initialized.')
del cfg
if (pGeometry.getGridColCount() != pDataObject3.getColCount() or \
pGeometry.getGridRowCount() != pDataObject3.getRowCount() or \
pGeometry.getGridSliceCount() != pDataObject3.getSliceCount()):
del pGeometry
raise Exception(
"The dimensions of the data do not match those specified in the geometry.")
pDataObject3.changeGeometry(pGeometry)
del pGeometry
else:
raise Exception("Not a known data object")
cdef fillDataObject(CFloat32Data3DMemory * obj, data):
if data is None:
fillDataObjectScalar(obj, 0)
else:
if isinstance(data, np.ndarray):
fillDataObjectArray(obj, np.ascontiguousarray(data,dtype=np.float32))
else:
fillDataObjectScalar(obj, np.float32(data))
cdef fillDataObjectScalar(CFloat32Data3DMemory * obj, float s):
cdef int i
for i in range(obj.getSize()):
obj.getData()[i] = s
@cython.boundscheck(False)
@cython.wraparound(False)
cdef fillDataObjectArray(CFloat32Data3DMemory * obj, float [:,:,::1] data):
if (not data.shape[0] == obj.getDepth()) or (not data.shape[1] == obj.getHeight()) or (not data.shape[2] == obj.getWidth()):
raise Exception(
"The dimensions of the data do not match those specified in the geometry.")
cdef float [:,:,::1] cView = <float[:data.shape[0],:data.shape[1],:data.shape[2]]> obj.getData3D()[0][0]
cView[:] = data
cdef CFloat32Data3D * getObject(i) except NULL:
cdef CFloat32Data3D * pDataObject = man3d.get(i)
if pDataObject == NULL:
raise Exception("Data object not found")
if not pDataObject.isInitialized():
raise Exception("Data object not initialized properly.")
return pDataObject
@cython.boundscheck(False)
@cython.wraparound(False)
def get(i):
cdef CFloat32Data3DMemory * pDataObject = dynamic_cast_mem(getObject(i))
outArr = np.empty((pDataObject.getDepth(),pDataObject.getHeight(), pDataObject.getWidth()),dtype=np.float32,order='C')
cdef float [:,:,::1] mView = outArr
cdef float [:,:,::1] cView = <float[:outArr.shape[0],:outArr.shape[1],:outArr.shape[2]]> pDataObject.getData3D()[0][0]
mView[:] = cView
return outArr
def get_shared(i):
cdef CFloat32Data3DMemory * pDataObject = dynamic_cast_mem(getObject(i))
outArr = np.empty((pDataObject.getDepth(),pDataObject.getHeight(), pDataObject.getWidth()),dtype=np.float32,order='C')
cdef np.npy_intp shape[3]
shape[0] = <np.npy_intp> pDataObject.getDepth()
shape[1] = <np.npy_intp> pDataObject.getHeight()
shape[2] = <np.npy_intp> pDataObject.getWidth()
return np.PyArray_SimpleNewFromData(3,shape,np.NPY_FLOAT32,<void *>pDataObject.getData3D()[0][0])
def get_single(i):
raise Exception("Not yet implemented")
def store(i,data):
cdef CFloat32Data3D * pDataObject = getObject(i)
fillDataObject(dynamic_cast_mem(pDataObject), data)
def dimensions(i):
cdef CFloat32Data3D * pDataObject = getObject(i)
return (pDataObject.getWidth(),pDataObject.getHeight(),pDataObject.getDepth())
def delete(ids):
try:
for i in ids:
man3d.remove(i)
except TypeError:
man3d.remove(ids)
def clear():
man3d.clear()
def info():
six.print_(wrap_from_bytes(man3d.info()))
|
