def download_images():
"""
Download all test images and
"""
root_dir = os.path.dirname(os.path.abspath(__file__))
test_dir = os.path.join(root_dir, PROJECT, "test")
sys.path.insert(0, test_dir)
from utilstest import UtilsTest
image_home = os.path.join(root_dir, "testimages")
testimages = os.path.join(root_dir, "all_testimages.json")
UtilsTest.image_home = image_home
UtilsTest.testimages = testimages
if os.path.exists(testimages):
import json
with open(testimages) as f:
all_files = set(json.load(f))
else:
raise(RuntimeError("Please run 'python setup.py build test' to download all images"))
for afile in all_files.copy():
if afile.endswith(".bz2"):
all_files.add(afile[:-4] + ".gz")
all_files.add(afile[:-4])
elif afile.endswith(".gz"):
all_files.add(afile[:-3] + ".bz2")
all_files.add(afile[:-3])
else:
all_files.add(afile + ".gz")
all_files.add(afile + ".bz2")
UtilsTest.download_images(all_files)
return list(all_files)
def setUp(self):
"""Download files"""
self.dataFile = UtilsTest.getimage(self.__class__.dataFile)
self.poniFile = UtilsTest.getimage(self.__class__.poniFile)
self.ai = pyFAI.load(self.poniFile)
self.data = fabio.open(self.dataFile).data
self.mask = self.data < 0
def setUp(self):
"""
download images
"""
UtilsTest.getimage(REFIMAGE)
self.im_dir = os.path.dirname(
UtilsTest.getimage(TESTIMAGES.split()[0] + ".bz2"))
class TestSparseBBox(unittest.TestCase):
"""Test Azimuthal integration based sparse matrix mutiplication methods
Bounding box pixel splitting
"""
N = 1000
unit = "2th_deg"
ai = pyFAI.load(UtilsTest.getimage("1893/Pilatus1M.poni"))
data = fabio.open(UtilsTest.getimage("1883/Pilatus1M.edf")).data
ref = ai.integrate1d(data, N, correctSolidAngle=False, unit=unit, method="splitBBox")[1]
cython = splitBBox.histoBBox1d(data, ai._ttha, ai._dttha, bins=N)
def test_LUT(self):
obt = self.ai.integrate1d(self.data, self.N, correctSolidAngle=False, unit=self.unit, method="LUT")[1]
logger.debug("delta on global result: %s" % (abs(obt - self.ref) / self.ref).max())
self.assert_(numpy.allclose(obt, self.ref))
cython = self.ai._lut_integrator.integrate(self.data)
for ref, obt in zip(self.cython, cython):
logger.debug("delta on cython result: %s" % (abs(obt - ref) / ref).max())
self.assert_(numpy.allclose(obt, ref))
def test_CSR(self):
obt = self.ai.integrate1d(self.data, self.N, correctSolidAngle=False, unit=self.unit, method="CSR")[1]
logger.debug("delta on global result: %s" % (abs(obt - self.ref) / self.ref).max())
self.assert_(numpy.allclose(obt, self.ref))
cython = self.ai._csr_integrator.integrate(self.data)
for ref, obt in zip(self.cython, cython):
logger.debug("delta on cython result: %s" % (abs(obt - ref) / ref).max())
self.assert_(numpy.allclose(obt, ref))
def setUp(self):
"""Download files"""
self.fit2dFile = UtilsTest.getimage(self.__class__.fit2dFile)
self.halfFrelon = UtilsTest.getimage(self.__class__.halfFrelon)
self.splineFile = UtilsTest.getimage(self.__class__.splineFile)
poniFile = UtilsTest.getimage(self.__class__.poniFile)
with open(poniFile) as f:
data = []
for line in f:
if line.startswith("SplineFile:"):
data.append("SplineFile: " + self.splineFile)
else:
data.append(line.strip())
self.poniFile = os.path.join(self.tmp_dir, os.path.basename(poniFile))
if not os.path.isdir(self.tmp_dir):
os.makedirs(self.tmp_dir)
with open(self.poniFile, "w") as f:
f.write(os.linesep.join(data))
self.fit2d = numpy.loadtxt(self.fit2dFile)
self.ai = AzimuthalIntegrator()
self.ai.load(self.poniFile)
self.data = fabio.open(self.halfFrelon).data
for tmpfile in self.tmpfiles.values():
if os.path.isfile(tmpfile):
os.unlink(tmpfile)
def setUp(self):
"""Download files"""
self.fit2dFile = UtilsTest.getimage(self.__class__.fit2dFile)
self.halfFrelon = UtilsTest.getimage(self.__class__.halfFrelon)
self.splineFile = UtilsTest.getimage(self.__class__.splineFile)
poniFile = UtilsTest.getimage(self.__class__.poniFile)
with open(poniFile) as f:
data = []
for line in f:
if line.startswith("SplineFile:"):
data.append("SplineFile: " + self.splineFile)
else:
data.append(line.strip())
self.poniFile = os.path.join(self.tmp_dir, os.path.basename(poniFile))
with open(self.poniFile, "w") as f:
f.write(os.linesep.join(data))
self.fit2d = numpy.loadtxt(self.fit2dFile)
self.ai = AzimuthalIntegrator()
self.ai.load(self.poniFile)
self.data = fabio.open(self.halfFrelon).data
if not os.path.isdir(self.tmp_dir):
os.makedirs(self.tmp_dir)
for tmpfile in self.tmpfiles.values():
if os.path.isfile(tmpfile):
os.unlink(tmpfile)
def setUp(self):
"""Download files"""
self.dataFile = UtilsTest.getimage(self.__class__.dataFile)
self.poniFile = UtilsTest.getimage(self.__class__.poniFile)
self.ai = pyFAI.load(self.poniFile)
self.data = fabio.open(self.dataFile).data
self.mask = self.data < 0
def setUp(self):
self.multiFrameFilename = UtilsTest.getimage("MultiFrame.edf.bz2")[:-4]
self.Frame0Filename = UtilsTest.getimage(
"MultiFrame-Frame0.edf.bz2")[:-4]
self.Frame1Filename = UtilsTest.getimage(
"MultiFrame-Frame1.edf.bz2")[:-4]
self.ref = edfimage()
self.frame0 = edfimage()
self.frame1 = edfimage()
try:
self.ref.read(self.multiFrameFilename)
except:
raise RuntimeError(
"Cannot read image multiFrameFilename image %s" %
self.multiFrameFilename)
try:
self.frame0.read(self.Frame0Filename)
except:
raise RuntimeError("Cannot read image Frame0File image %s" %
self.Frame0File)
try:
self.frame1.read(self.Frame1Filename)
except:
raise RuntimeError("Cannot read image Frame1File image %s" %
self.Frame1File)
def download_images():
"""
Download all test images and
"""
root_dir = os.path.dirname(os.path.abspath(__file__))
test_dir = os.path.join(root_dir, PROJECT, "test")
sys.path.insert(0, test_dir)
from utilstest import UtilsTest
image_home = os.path.join(root_dir, "testimages")
testimages = os.path.join(root_dir, "all_testimages.json")
UtilsTest.image_home = image_home
UtilsTest.testimages = testimages
if os.path.exists(testimages):
import json
with open(testimages) as f:
all_files = set(json.load(f))
else:
raise (RuntimeError(
"Please run 'python setup.py build test' to download all images"))
for afile in all_files.copy():
if afile.endswith(".bz2"):
all_files.add(afile[:-4] + ".gz")
all_files.add(afile[:-4])
elif afile.endswith(".gz"):
all_files.add(afile[:-3] + ".bz2")
all_files.add(afile[:-3])
else:
all_files.add(afile + ".gz")
all_files.add(afile + ".bz2")
UtilsTest.download_images(all_files)
return list(all_files)
def download_images():
"""
Download all test images and
"""
test_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "test")
sys.path.insert(0, test_dir)
from utilstest import UtilsTest
UtilsTest.download_images()
return list(UtilsTest.ALL_DOWNLOADED_FILES)
def setUp(self):
"""Download files"""
self.fit2dFile = UtilsTest.getimage(self.__class__.fit2d_cor)
self.halfFrelon = UtilsTest.getimage(self.__class__.halfFrelon)
self.splineFile = UtilsTest.getimage(self.__class__.splineFile)
self.det = detectors.FReLoN(self.splineFile)
self.dis = _distortion.Distortion(self.det)
self.fit2d = fabio.open(self.fit2dFile).data
self.raw = fabio.open(self.halfFrelon).data
def setUp(self):
"""Download files"""
self.fit2dFile = UtilsTest.getimage(self.__class__.fit2d_cor)
self.halfFrelon = UtilsTest.getimage(self.__class__.halfFrelon)
self.splineFile = UtilsTest.getimage(self.__class__.splineFile)
self.det = detectors.FReLoN(self.splineFile)
self.dis = _distortion.Distortion(self.det)
self.fit2d = fabio.open(self.fit2dFile).data
self.raw = fabio.open(self.halfFrelon).data
def download_images():
"""
Download all test images and
"""
test_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "test")
sys.path.insert(0, test_dir)
from utilstest import UtilsTest
UtilsTest.download_images()
return list(UtilsTest.ALL_DOWNLOADED_FILES)
def setUp(self):
self.edfPilatus = UtilsTest.getimage(self.__class__.saxsPilatus)
self.maskFile = UtilsTest.getimage(self.__class__.maskFile)
self.poniFile = UtilsTest.getimage(self.__class__.poniFile)
self.maskRef = UtilsTest.getimage(self.__class__.maskRef)
self.maskDummy = UtilsTest.getimage(self.__class__.maskDummy)
self.ai = AzimuthalIntegrator()
self.ai.load(self.poniFile)
if not os.path.isdir(self.tmp_dir):
os.mkdir(self.tmp_dir)
def setUp(self):
self.edfPilatus = UtilsTest.getimage(self.__class__.saxsPilatus)
self.maskFile = UtilsTest.getimage(self.__class__.maskFile)
self.poniFile = UtilsTest.getimage(self.__class__.poniFile)
self.maskRef = UtilsTest.getimage(self.__class__.maskRef)
self.maskDummy = UtilsTest.getimage(self.__class__.maskDummy)
self.ai = AzimuthalIntegrator()
self.ai.load(self.poniFile)
if not os.path.isdir(self.tmp_dir):
os.mkdir(self.tmp_dir)
def setUp(self):
"""Download files"""
self.fit2dFile = UtilsTest.getimage(self.__class__.fit2dFile)
self.pilatusFile = UtilsTest.getimage(self.__class__.pilatusFile)
self.tth_fit2d, self.I_fit2d = numpy.loadtxt(self.fit2dFile, unpack=True)
self.ai = pyFAI.AzimuthalIntegrator(dist=1.994993e-01,
poni1=2.143248e-01,
poni2=2.133315e-01,
rot1=0.007823,
rot2=0.006716,
rot3=0,
pixel1=172e-6,
pixel2=172e-6)
self.data = fabio.open(self.pilatusFile).data
self.data[self.data < 0] = 0 #discard negative pixels
def setUp(self):
"""Download files"""
self.fit2dFile = UtilsTest.getimage(self.__class__.fit2dFile)
self.pilatusFile = UtilsTest.getimage(self.__class__.pilatusFile)
self.tth_fit2d, self.I_fit2d = numpy.loadtxt(self.fit2dFile, unpack=True)
self.ai = AzimuthalIntegrator(dist=1.994993e-01,
poni1=2.143248e-01,
poni2=2.133315e-01,
rot1=0.007823,
rot2=0.006716,
rot3=0,
pixel1=172e-6,
pixel2=172e-6)
self.data = fabio.open(self.pilatusFile).data
self.data[self.data < 0] = 0 #discard negative pixels
def setUp(self):
"""Download files"""
self.fn = {}
for i in ["i01f0001.kcd", "i01f0001.edf"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
for i in self.fn:
assert os.path.exists(self.fn[i])
def setUp(self):
"""
download images
"""
self.im_dir = os.path.dirname(UtilsTest.getimage("Cr8F8140k103.0026.bz2"))
self.tempdir = tempfile.mkdtemp()
def setUp(self):
self.fn = {}
for i in ["b191_1_9_1.img", "b191_1_9_1_uncompressed.img"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
for i in self.fn:
assert os.path.exists(self.fn[i])
self.tempdir = tempfile.mkdtemp()
def setUp(self):
self.fn = {}
for i in ["b191_1_9_1.img", "b191_1_9_1_uncompressed.img"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
for i in self.fn:
assert os.path.exists(self.fn[i])
self.tempdir = tempfile.mkdtemp()
def setUp(self):
"""Download files"""
self.fn = {}
for i in ["i01f0001.kcd", "i01f0001.edf"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
for i in self.fn:
assert os.path.exists(self.fn[i])
def setUp(self):
"""Download files"""
self.fn = {}
for j in self.results.split("\n"):
i = j.split()[0]
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
for i in self.fn:
assert os.path.exists(self.fn[i])
def setUp(self):
"""
download images
"""
self.im_dir = os.path.dirname(
UtilsTest.getimage("Cr8F8140k103.0026.bz2"))
self.tempdir = tempfile.mkdtemp()
def setUp(self):
"""Download files"""
self.img = UtilsTest.getimage(self.__class__.calibFile)
self.pp = PeakPicker(self.img, dSpacing=self.ds, wavelength=self.wavelength)
dirname = os.path.dirname(os.path.abspath(__file__))
self.tmpdir = os.path.join(dirname, "tmp")
if not os.path.isdir(self.tmpdir):
os.mkdir(self.tmpdir)
def setUp(self):
self.fn = {}
for i in ["corkcont2_H_0089.mccd", "somedata_0001.mccd"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
self.fn[i + ".bz2"] = self.fn[i] + ".bz2"
self.fn[i + ".gz"] = self.fn[i] + ".gz"
for i in self.fn:
assert os.path.exists(self.fn[i])
def setUp(self):
self.fn = {}
for i in ["corkcont2_H_0089.mccd", "somedata_0001.mccd"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
self.fn[i + ".bz2"] = self.fn[i] + ".bz2"
self.fn[i + ".gz"] = self.fn[i] + ".gz"
for i in self.fn:
assert os.path.exists(self.fn[i])
def setUp(self):
"""Download files"""
self.img = UtilsTest.getimage(self.__class__.calibFile)
self.pp = PeakPicker(self.img, dSpacing=self.ds, wavelength=self.wavelength)
dirname = os.path.dirname(os.path.abspath(__file__))
self.tmpdir = os.path.join(dirname, "tmp")
if not os.path.isdir(self.tmpdir):
os.mkdir(self.tmpdir)
def setUp(self):
"""Download files"""
self.fn = {}
for j in self.results.split("\n"):
i = j.split()[0]
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
for i in self.fn:
assert os.path.exists(self.fn[i])
def download_images():
"""
Download all test images and
"""
test_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "test")
sys.path.insert(0, test_dir)
from utilstest import UtilsTest
for afile in UtilsTest.ALL_DOWNLOADED_FILES.copy():
if afile.endswith(".bz2"):
UtilsTest.ALL_DOWNLOADED_FILES.add(afile[:-4] + ".gz")
UtilsTest.ALL_DOWNLOADED_FILES.add(afile[:-4])
elif afile.endswith(".gz"):
UtilsTest.ALL_DOWNLOADED_FILES.add(afile[:-3] + ".bz2")
UtilsTest.ALL_DOWNLOADED_FILES.add(afile[:-3])
else:
UtilsTest.ALL_DOWNLOADED_FILES.add(afile + ".gz")
UtilsTest.ALL_DOWNLOADED_FILES.add(afile + ".bz2")
UtilsTest.download_images()
return list(UtilsTest.ALL_DOWNLOADED_FILES)
def download_images():
"""
Download all test images and
"""
test_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "test")
sys.path.insert(0, test_dir)
from utilstest import UtilsTest
for afile in UtilsTest.ALL_DOWNLOADED_FILES.copy():
if afile.endswith(".bz2"):
UtilsTest.ALL_DOWNLOADED_FILES.add(afile[:-4] + ".gz")
UtilsTest.ALL_DOWNLOADED_FILES.add(afile[:-4])
elif afile.endswith(".gz"):
UtilsTest.ALL_DOWNLOADED_FILES.add(afile[:-3] + ".bz2")
UtilsTest.ALL_DOWNLOADED_FILES.add(afile[:-3])
else:
UtilsTest.ALL_DOWNLOADED_FILES.add(afile + ".gz")
UtilsTest.ALL_DOWNLOADED_FILES.add(afile + ".bz2")
UtilsTest.download_images()
return list(UtilsTest.ALL_DOWNLOADED_FILES)
def setUp(self):
self.multiFrameFilename = UtilsTest.getimage("MultiFrame.edf.bz2")[:-4]
self.Frame0Filename = UtilsTest.getimage("MultiFrame-Frame0.edf.bz2")[:-4]
self.Frame1Filename = UtilsTest.getimage("MultiFrame-Frame1.edf.bz2")[:-4]
self.ref = edfimage()
self.frame0 = edfimage()
self.frame1 = edfimage()
try:
self.ref.read(self.multiFrameFilename)
except:
raise RuntimeError("Cannot read image multiFrameFilename image %s" % self.multiFrameFilename)
try:
self.frame0.read(self.Frame0Filename)
except:
raise RuntimeError("Cannot read image Frame0File image %s" % self.Frame0File)
try:
self.frame1.read(self.Frame1Filename)
except:
raise RuntimeError("Cannot read image Frame1File image %s" % self.Frame1File)
def setUp(self):
"""Download files"""
self.img = UtilsTest.getimage(self.__class__.calibFile)
self.pp = PeakPicker(self.img, calibrant=self.calibrant, wavelength=self.wavelength)
if not os.path.isdir(self.tmp_dir):
os.makedirs(self.tmp_dir)
if os.path.isfile(self.logfile):
os.unlink(self.logfile)
if os.path.isfile(self.nptfile):
os.unlink(self.nptfile)
def setUp(self):
"""Download files"""
self.img = UtilsTest.getimage(self.__class__.calibFile)
self.pp = PeakPicker(self.img, dSpacing=self.ds, wavelength=self.wavelength)
if not os.path.isdir(self.tmp_dir):
os.makedirs(self.tmp_dir)
if os.path.isfile(self.logfile):
os.unlink(self.logfile)
if os.path.isfile(self.nptfile):
os.unlink(self.nptfile)
def setUp(self):
"""
Download files
Create a mask for tth<3.7 deg
"""
self.dataFile = UtilsTest.getimage(self.__class__.dataFile)
detector = pyFAI.detectors.Detector(pixel1=0.0001, pixel2=0.0001)
self.ai = pyFAI.AzimuthalIntegrator(dist=0.1, poni1=0.03, poni2=0.03, detector=detector)
self.data = fabio.open(self.dataFile).data
self.tth, self.I = self.ai.integrate1d(self.data, 1000, unit="2th_deg")
self.mask = self.ai.ttha < numpy.deg2rad(3.7)
def setUp(self):
"""
Download files
Create a mask for tth<3.7 deg
"""
self.dataFile = UtilsTest.getimage(self.__class__.dataFile)
detector = pyFAI.detectors.Detector(pixel1=0.0001, pixel2=0.0001)
self.ai = pyFAI.AzimuthalIntegrator(dist=0.1, poni1=0.03, poni2=0.03, detector=detector)
self.data = fabio.open(self.dataFile).data
self.tth, self.I = self.ai.integrate1d(self.data, 1000, unit="2th_deg")
self.mask = self.ai.ttha < numpy.deg2rad(3.7)
def setUp(self):
"""Download files"""
self.fit2dFile = UtilsTest.getimage(self.__class__.fit2dFile)
self.halfFrelon = UtilsTest.getimage(self.__class__.halfFrelon)
self.splineFile = UtilsTest.getimage(self.__class__.splineFile)
self.poniFile = UtilsTest.getimage(self.__class__.poniFile)
with open(self.poniFile) as f:
data = []
for line in f:
if line.startswith("SplineFile:"):
data.append("SplineFile: " + self.splineFile)
else:
data.append(line.strip())
with open(self.poniFile, "w") as f:
f.write(os.linesep.join(data))
self.fit2d = numpy.loadtxt(self.fit2dFile)
self.ai = AzimuthalIntegrator()
self.ai.load(self.poniFile)
self.data = fabio.open(self.halfFrelon).data
if not os.path.isdir("tmp"):
os.mkdir("tmp")
def setUp(self):
"""Download files"""
self.fit2dFile = UtilsTest.getimage(self.__class__.fit2dFile)
self.halfFrelon = UtilsTest.getimage(self.__class__.halfFrelon)
self.splineFile = UtilsTest.getimage(self.__class__.splineFile)
self.poniFile = UtilsTest.getimage(self.__class__.poniFile)
with open(self.poniFile) as f:
data = []
for line in f:
if line.startswith("SplineFile:"):
data.append("SplineFile: " + self.splineFile)
else:
data.append(line.strip())
with open(self.poniFile, "w") as f:
f.write(os.linesep.join(data))
self.fit2d = numpy.loadtxt(self.fit2dFile)
self.ai = AzimuthalIntegrator()
self.ai.load(self.poniFile)
self.data = fabio.open(self.halfFrelon).data
if not os.path.isdir("tmp"):
os.mkdir("tmp")
def setUp(self):
self.datasets = [
{
"img": UtilsTest.getimage("1883/Pilatus1M.edf"),
"poni": UtilsTest.getimage("1893/Pilatus1M.poni"),
"spline": None
},
{
"img": UtilsTest.getimage("1882/halfccd.edf"),
"poni": UtilsTest.getimage("1895/halfccd.poni"),
"spline": UtilsTest.getimage("1461/halfccd.spline")
},
{
"img": UtilsTest.getimage("1881/Frelon2k.edf"),
"poni": UtilsTest.getimage("1896/Frelon2k.poni"),
"spline": UtilsTest.getimage("1900/frelon.spline")
},
{
"img": UtilsTest.getimage("1884/Pilatus6M.cbf"),
"poni": UtilsTest.getimage("1897/Pilatus6M.poni"),
"spline": None
},
# {"img":UtilsTest.getimage("1880/Fairchild.edf"), "poni":UtilsTest.getimage("1898/Fairchild.poni"), "spline": None},
]
for ds in self.datasets:
if ds["spline"] is not None:
data = open(ds["poni"], "r").read()
# spline = os.path.basename(ds["spline"])
with open(ds["poni"]) as f:
data = []
for line in f:
if line.startswith("SplineFile:"):
data.append("SplineFile: " + ds["spline"])
else:
data.append(line.strip())
ds["poni"] = os.path.join(self.tmp_dir,
os.path.basename(ds["poni"]))
with open(ds["poni"], "w") as f:
f.write(os.linesep.join(data))
class TestAzimPilatus(unittest.TestCase):
img = UtilsTest.getimage("1884/Pilatus6M.cbf")
def setUp(self):
"""Download files"""
self.data = fabio.open(self.img).data
self.ai = AzimuthalIntegrator(detector="pilatus6m")
self.ai.setFit2D(300, 1326, 1303)
def test_separate(self):
maxi = self.data.max()
mini = self.data.min()
bragg, amorphous = self.ai.separate(self.data)
self.assert_(amorphous.max()<bragg.max(), "bragg is more intense than amorphous")
def test_read(self):
"""
Test the reading of Mar345 images
"""
for line in TESTIMAGES.split('\n'):
vals = line.strip().split()
name = vals[0]
dim1, dim2 = [int(x) for x in vals[1:3]]
mini, maxi, mean, stddev = [float(x) for x in vals[3:]]
obj = mar345image()
obj.read(UtilsTest.getimage(name))
self.assertAlmostEqual(mini, obj.getmin(), 2, "getmin [%s,%s]" % (mini, obj.getmin()))
self.assertAlmostEqual(maxi, obj.getmax(), 2, "getmax [%s,%s]" % (maxi, obj.getmax()))
self.assertAlmostEqual(mean, obj.getmean(), 2, "getmean [%s,%s]" % (mean, obj.getmean()))
self.assertAlmostEqual(stddev, obj.getstddev(), 2, "getstddev [%s,%s]" % (stddev, obj.getstddev()))
self.assertEqual(dim1, obj.dim1, "dim1")
self.assertEqual(dim2, obj.dim2, "dim2")
def setUp(self):
self.datasets = [{"img":UtilsTest.getimage("1883/Pilatus1M.edf"), "poni":UtilsTest.getimage("1893/Pilatus1M.poni"), "spline": None},
{"img":UtilsTest.getimage("1882/halfccd.edf"), "poni":UtilsTest.getimage("1895/halfccd.poni"), "spline": UtilsTest.getimage("1461/halfccd.spline")},
{"img":UtilsTest.getimage("1881/Frelon2k.edf"), "poni":UtilsTest.getimage("1896/Frelon2k.poni"), "spline": UtilsTest.getimage("1900/frelon.spline")},
{"img":UtilsTest.getimage("1884/Pilatus6M.cbf"), "poni":UtilsTest.getimage("1897/Pilatus6M.poni"), "spline": None},
# {"img":UtilsTest.getimage("1880/Fairchild.edf"), "poni":UtilsTest.getimage("1898/Fairchild.poni"), "spline": None},
]
for ds in self.datasets:
if ds["spline"] is not None:
data = open(ds["poni"], "r").read()
# spline = os.path.basename(ds["spline"])
with open(ds["poni"]) as f:
data = []
for line in f:
if line.startswith("SplineFile:"):
data.append("SplineFile: " + ds["spline"])
else:
data.append(line.strip())
with open(ds["poni"], "w") as f:
f.write(os.linesep.join(data))
def __init__(self, filename=None, devicetype=None, device=None, profile=False):
if filename and os.path.exists(filename):
self.filename = filename
else:
self.filename = UtilsTest.getimage("wikipedia/commons/9/94/Esrf_grenoble.jpg")
self.image_rgb = scipy.misc.imread(self.filename)
if self.image_rgb.ndim != 2:
self.image_bw = 0.299 * self.image_rgb[:, :, 0] + 0.587 * self.image_rgb[:, :, 1] + 0.114 * self.image_rgb[:, :, 2]
else: self.image_bw = self.image_rgb
if feature:
self._sift_cpp = feature.SiftAlignment()
self._sift_ocl = sift.SiftPlan(template=self.image_rgb, device=device, devicetype=devicetype, profile=profile)
self.kp_cpp = numpy.empty(0)
self.kp_ocl = numpy.empty(0)
self.fig = pylab.figure()
self.sp1 = self.fig.add_subplot(1, 2, 1)
self.im1 = self.sp1.imshow(self.image_rgb)
self.sp1.set_title("OpenCL: %s keypoint" % self.kp_ocl.size)
self.sp2 = self.fig.add_subplot(1, 2, 2)
self.im2 = self.sp2.imshow(self.image_bw, cmap="gray")
self.sp2.set_title("C++: %s keypoint" % self.kp_cpp.size)
self.fig.show()
self.timing_cpp = None
self.timing_ocl = None
def setUp(self):
self.fn = {}
for i in ["a0009.tif", "a0009.edf"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
for i in self.fn:
assert os.path.exists(self.fn[i])
logging.basicConfig(level=logging.DEBUG)
sys.argv.pop(sys.argv.index(opts))
elif opts in ["-i", "--info"]:
logging.basicConfig(level=logging.INFO)
sys.argv.pop(sys.argv.index(opts))
elif opts in ["-f", "--force"]:
force_build = True
sys.argv.pop(sys.argv.index(opts))
try:
logger.debug("Tests loaded from file: %s" % __file__)
except:
__file__ = os.getcwd()
from utilstest import UtilsTest
if force_build:
UtilsTest.forceBuild()
import fabio
from fabio.kcdimage import kcdimage
from fabio.edfimage import edfimage
from fabio.openimage import openimage
class testkcd(unittest.TestCase):
"""basic test"""
kcdfilename = 'i01f0001.kcd'
edffilename = 'i01f0001.edf'
results = """i01f0001.kcd 625 576 96 66814.0 195.3862972 243.58150990245315"""
def setUp(self):
logging.basicConfig(level=logging.DEBUG)
sys.argv.pop(sys.argv.index(opts))
elif opts in ["-i", "--info"]:
logging.basicConfig(level=logging.INFO)
sys.argv.pop(sys.argv.index(opts))
elif opts in ["-f", "--force"]:
force_build = True
sys.argv.pop(sys.argv.index(opts))
try:
logger.debug("Tests loaded from file: %s" % __file__)
except:
__file__ = os.getcwd()
from utilstest import UtilsTest
if force_build:
UtilsTest.forceBuild()
import fabio
from fabio.fabioimage import fabioimage
import numpy
import gzip, bz2
class test50000(unittest.TestCase):
""" test with 50000 everywhere"""
def setUp(self):
"""make the image"""
dat = numpy.ones((1024, 1024), numpy.uint16)
dat = (dat * 50000).astype(numpy.uint16)
assert dat.dtype.char == numpy.ones((1), numpy.uint16).dtype.char
hed = {"Title": "50000 everywhere"}
self.obj = fabioimage(dat, hed)
def tearDown(self):
UtilsTest.recursive_delete(self.tempdir)
def setUp(self):
self.fn = {}
for i in ["d80_60s.img", "d80_60s.edf"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")[:-4]
for i in self.fn:
self.assertTrue(os.path.exists(self.fn[i]), self.fn[i])
def setUp(self):
self.fname = UtilsTest.getimage("mb_LP_1_001.img.bz2")
#!/usr/bin/python
import sys, os
import numpy
import fabio
from utilstest import UtilsTest
pyFAI = UtilsTest.pyFAI
data = fabio.open(UtilsTest.getimage("1788/moke.tif")).data
ai = pyFAI.AzimuthalIntegrator.sload("moke.poni")
ai.xrpd(data, 1000)
tth = ai.twoThetaArray(data.shape)
dtth = ai.delta2Theta(data.shape)
o1 = ai.xrpd(data, 1000)
o2 = ai.xrpd(data, 1000, tthRange=[3.5, 12.5])
o3 = ai.xrpd(data, 1000, chiRange=[10, 80])
o4 = ai.xrpd2(data, 100, 36, tthRange=[3.5, 12.5], chiRange=[10, 80])
from pylab import *
plot(o1[0], o1[1], "b")
plot(o2[0], o2[1], "r")
plot(o3[0], o3[1], "g")
imshow(o4[0])
show()
def setUp(self):
self.fn = {}
for i in ["fit2d.tif", "fit2d.edf"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")
for i in self.fn:
assert os.path.exists(self.fn[i])
def setUp(self):
self.fn = {}
for i in ["oPPA_5grains_0001.tif", "oPPA_5grains_0001.edf"]:
self.fn[i] = UtilsTest.getimage(i + ".bz2")
for i in self.fn:
assert os.path.exists(self.fn[i])
def setUp(self):
self.name = UtilsTest.getimage("F2K_Seb_Lyso0675_header_only.edf.bz2")[:-4]
testsuite by Jerome Kieffer ([email protected]) 28/11/2014 """ from __future__ import print_function, with_statement, division, absolute_import import unittest import sys import os try: from .utilstest import UtilsTest except (ValueError, SystemError): from utilstest import UtilsTest logger = UtilsTest.get_logger(__file__) fabio = sys.modules["fabio"] CASES = [ (1, 'edf', "data0001.edf"), (10001, 'edf', "data10001.edf"), (10001, 'edf', "data10001.edf.gz"), (10001, 'edf', "data10001.edf.bz2"), (2, 'marccd', "data0002.mccd"), (12345, 'marccd', "data12345.mccd"), (10001, 'marccd', "data10001.mccd.gz"), (10001, 'marccd', "data10001.mccd.bz2"), (123, 'marccd', "data123.mccd.gz"), (3, 'tif', "data0003.tif"), (4, 'tif', "data0004.tiff"), (12, 'bruker', "sucrose101.012.gz"),
def setUp(self):
self.unzipped = UtilsTest.getimage("oPPA_5grains_0001.tif.bz2")[:-4]
self.zipped = self.unzipped + ".gz"
assert os.path.exists(self.zipped)
assert os.path.exists(self.unzipped)
def setUp(self):
"""
download images
"""
self.filename = UtilsTest.getimage("fit2d_click.msk.bz2")[:-4]
self.edffilename = UtilsTest.getimage("fit2d_click.edf.bz2")[:-4]
def setUp(self):
self.fname = UtilsTest.getimage(self.__class__.fname)
