def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultSaxsMacv1_0.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same")
outputData = openimage(
xsDataResultObtained.getOutputImage().getPath().getValue()).data
referenceData = openimage(
os.path.join(self.getTestsDataImagesHome(), "moke.edf")).data
EDAssert.arraySimilar(outputData,
referenceData,
_fAbsMaxDelta=0.8,
_fScaledMaxDelta=0.05,
_fRfactor=5,
_fRelMaxDelta=1.5,
_strComment="Images are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
# Checking obtained results
xsDataResult = plugin.getDataOutput()
xsDataRef = XSDataResult1DPowderEDF.parseString(
self.readAndParseFile(self.getReferenceDataOutputFile()))
# EDAssert.strAlmostEqual(XSDataResult1DPowderEDF.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())).marshal(), xsDataResult.marshal(), _strComment="XML structures are the same")
tthref = EDUtilsArray.xsDataToArray(xsDataRef.getTwoTheta(),
_bCheckMd5sum=False)
tthobt = EDUtilsArray.xsDataToArray(xsDataResult.getTwoTheta(),
_bCheckMd5sum=False)
Iref = EDUtilsArray.xsDataToArray(xsDataRef.getIntensity(),
_bCheckMd5sum=False)
Iobt = EDUtilsArray.xsDataToArray(xsDataResult.getIntensity(),
_bCheckMd5sum=False)
EDAssert.arraySimilar(_npaValue=tthobt,
_npaRef=tthref,
_fAbsMaxDelta=0.1,
_strComment="2theta arrays are the same")
EDAssert.arraySimilar(_npaValue=Iobt,
_npaRef=Iref,
_fAbsMaxDelta=0.1,
_strComment="Intensity arrays are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
EDVerbose.DEBUG("Checking obtained result...")
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
xsDataResultReference = XSDataResultSPDCake.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
# EDVerbose.DEBUG("Reference XML:%s" + xsDataResultReference.marshal())
# EDVerbose.DEBUG("Obtained XML:%s" + xsDataResultObtained.marshal())
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same")
# Checking obtained results
xsDataResultsSPDCake = plugin.getDataOutput()
strPathToChiOutput = xsDataResultsSPDCake.getCakedFile().getPath().getValue()
strPathToChiReference = os.path.join(self.getTestsDataImagesHome(), "EDPluginSPDCakev1_0.chi")
Xref, Yref = readChiPlot(strPathToChiReference)
Xobt, Yobt = readChiPlot(strPathToChiOutput)
EDVerbose.DEBUG("Output File: %s, Reference file: %s" % (strPathToChiOutput, strPathToChiReference))
bigX = Xref + Xobt
bigX.sort()
bigYobt = numpy.interp(bigX, Xobt, Yobt)
bigYref = numpy.interp(bigX, Xref, Yref)
EDVerbose.DEBUG("ref.shape= %s, obt.shape=%s" % (bigYobt.shape, bigYref.shape))
EDVerbose.DEBUG("Type of object ref= %s, obt=%s" % (bigYobt.__class__, bigYref.__class__))
EDAssert.arraySimilar(bigYobt, bigYref, _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.1, _strComment="Comparing ChiPlot files")
def testExecute(self):
"""
"""
self.run()
# plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
strObtainedOutput = self.readAndParseFile(
self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultNormalize.parseString(
strExpectedOutput)
xsDataResultObtained = XSDataResultNormalize.parseString(
strObtainedOutput)
#EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "Result XML are the same")
npaReference = EDUtilsArray.getArray(xsDataResultReference.output)
npaObtained = EDUtilsArray.getArray(xsDataResultObtained.output)
EDAssert.arraySimilar(npaReference,
npaObtained,
"Arrays are the same",
_fAbsMaxDelta=1e-6)
EDAssert.equal(npaReference.dtype, npaObtained.dtype,
"Datatypes are the same")
def testExecute(self):
"""
"""
self.run()
# Checks that there are no error messages
plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultExecThumbnail.parseString(strExpectedOutput)
xsDataResultObtained = XSDataResultExecThumbnail.parseString(strObtainedOutput)
EDAssert.equal(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XML are the same")
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
xsDataResultReference = XSDataResultExecThumbnail.parseString(strExpectedOutput)
outputFileName = xsDataResultReference.getThumbnailPath().getPath().getValue()
outputImage = Image.open(outputFileName)
self.loadTestImage([os.path.basename(outputFileName)])
referenceFileName = os.path.join(EDUtilsPath.EDNA_TESTIMAGES, os.path.basename(outputFileName))
referenceImage = Image.open(referenceFileName)
EDAssert.arraySimilar(numpy.asarray(outputImage), numpy.asarray(referenceImage), _strComment="Images are the same", _fAbsMaxDelta=5)
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultMatrixInvertFile.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), _strComment="XSDataResult output are the same")
################################################################################
# Check that outputData * inputData - Id = 0
################################################################################
outputData = openimage(self.outputFile).data
size = outputData.shape[0]
inputData = openimage(self.inputFile).data
EDAssert.arraySimilar(numpy.matrix(outputData) * numpy.matrix(inputData), numpy.identity(size), _fAbsMaxDelta=2e-4, _strComment="output x input = Id ")
################################################################################
# Compare image Files
################################################################################
referenceData = openimage(os.path.join(self.getTestsDataImagesHome(), os.path.basename(self.outputFile))).data
EDAssert.arraySimilar(referenceData, outputData, _fAbsMaxDelta=1e-5, _strComment="images are the same")
def testSpatialDistortion(self):
strRefX = "spline-3-18x.edf"
strRefY = "spline-3-18y.edf"
self.loadTestImage([strRefX, strRefY])
edPluginSPD = self.createPlugin()
strXMLInput = EDUtilsFile.readFileAndParseVariables(self.strReferenceInputFileName)
xsDataInputSPDCake = XSDataInputSPDCake.parseString(strXMLInput)
edPluginSPD.setDataInput(xsDataInputSPDCake)
edPluginSPD.configure()
edPluginSPD.getInputParameter()
########################################################################
# Enforce some values
########################################################################
edPluginSPD.dictGeometry["SpatialDistortionFile"] = os.path.join(self.getTestsDataImagesHome(), "frelon_spline_file_to_correct_SPD.spline")
edPluginSPD.dictGeometry["TiltRotation"] = 18
edPluginSPD.dictGeometry["AngleOfTilt"] = 3
spline = Spline()
spline.read(edPluginSPD.dictGeometry["SpatialDistortionFile"])
edPluginSPD.dictGeometry["PixelSizeX"], edPluginSPD.dictGeometry["PixelSizeY"] = spline.getPixelSize()
edPluginSPD.createDisplacementMatrix(spline)
edPluginSPD.cleanDispMat(edPluginSPD.getWorkingDirectory())
refX = fabio.openimage.openimage(os.path.join(self.getTestsDataImagesHome(), strRefX)).data
obtX = fabio.openimage.openimage(os.path.join(edPluginSPD.getWorkingDirectory(), "frelon_spline_file_to_correct_SPD-tilted-x.edf")).data
refY = fabio.openimage.openimage(os.path.join(self.getTestsDataImagesHome(), strRefY)).data
obtY = fabio.openimage.openimage(os.path.join(edPluginSPD.getWorkingDirectory(), "frelon_spline_file_to_correct_SPD-tilted-y.edf")).data
# print edPluginSPD.dictGeometry
EDAssert.arraySimilar(obtX, refX , _fAbsMaxDelta=0.1, _strComment="X displacement Matrix is the same")
EDAssert.arraySimilar(obtY, refY , _fAbsMaxDelta=0.1, _strComment="Y displacement Matrix is the same")
def testExecute(self):
"""
"""
self.run()
# Checks that there are no error messages
plugin = self.getPlugin()
plugin.killAllWorkers()
if EDVerbose.isVerboseDebug():
plugin.cleanDispMat(plugin.getWorkingDirectory())
else:
plugin.cleanDispMat()
# Checking obtained results
xsDataResultSPD = plugin.getDataOutput()
EDVerbose.DEBUG("outfile = %s" % xsDataResultSPD.getCorrectedFile().getPath().getValue())
EDVerbose.DEBUG("reffile = %s" % os.path.join(self.getTestsDataImagesHome(), self.refOutput))
outputData = openimage(xsDataResultSPD.getCorrectedFile().getPath().getValue()).data
referenceData = openimage(os.path.join(self.getTestsDataImagesHome(), self.refOutput)).data
# res = 100 * (abs(outputData - referenceData).max() - referenceData.min()) / (referenceData.max() - referenceData.min())
# EDVerbose.screen("Maximum error = %.2f%%" % res)
# EDAssert.equal((res < 5), True)
EDAssert.arraySimilar(outputData, referenceData, "Simple comparison")
EDAssert.arraySimilar(outputData, referenceData, _fAbsMaxDelta=0.01, _fScaledMaxDelta=0.05, _strComment="Images comparison")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
# Checking obtained results
xsDataResult = plugin.getDataOutput()
xsDataRef = XSDataResult1DPowderEDF.parseString(
self.readAndParseFile(self.getReferenceDataOutputFile()))
# EDAssert.strAlmostEqual(XSDataResult1DPowderEDF.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())).marshal(), xsDataResult.marshal(), _strComment="XML structures are the same")
tthref = EDUtilsArray.xsDataToArray(
xsDataRef.getTwoTheta(), _bCheckMd5sum=False)
tthobt = EDUtilsArray.xsDataToArray(
xsDataResult.getTwoTheta(), _bCheckMd5sum=False)
Iref = EDUtilsArray.xsDataToArray(
xsDataRef.getIntensity(), _bCheckMd5sum=False)
Iobt = EDUtilsArray.xsDataToArray(
xsDataResult.getIntensity(), _bCheckMd5sum=False)
EDAssert.arraySimilar(
_npaValue=tthobt,
_npaRef=tthref,
_fAbsMaxDelta=0.1,
_strComment="2theta arrays are the same")
EDAssert.arraySimilar(
_npaValue=Iobt,
_npaRef=Iref,
_fAbsMaxDelta=0.1,
_strComment="Intensity arrays are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsProcessOneFilev1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare dictionary
################################################################################
obtFile = xsDataResultObtained.integratedImage.path.value
refFile = os.path.join(self.getTestsDataImagesHome(), "bioSaxsProcessIntegrated.edf")
EDVerbose.DEBUG("fileRef=%s fileObt=%s" % (refFile, obtFile))
edfRef = openimage(refFile)
edfObt = openimage(obtFile)
headerRef = edfRef.header
headerObt = edfObt.header
keysRef = headerRef.keys()
keysObt = headerObt.keys()
keysRef.sort()
keysObt.sort()
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dict")
for key in keysRef:
if not (key.startswith("History") or key in [ "Compression", "DDummy", "Dummy", "EDF_HeaderSize", "HeaderID", "Image", "filename", "RasterOrientation"]):
EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfRef.data
referenceData = edfObt.data
EDAssert.arraySimilar(numpy.maximum(outputData, 0), numpy.maximum(referenceData, 0) , _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
outputData = edfRef.next().data
referenceData = edfObt.next().data
EDAssert.arraySimilar(numpy.maximum(outputData, 0), numpy.maximum(referenceData, 0) , _fScaledMaxDelta=0.05, _strComment="Images-ESD are the same")
################################################################################
# Compare Ascii files
################################################################################
asciiObt = os.linesep.join([i.strip() for i in open(xsDataResultObtained.integratedCurve.path.value) if "Raster" not in i])
asciiRef = os.linesep.join([i.strip() for i in open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsProcessIntegrated1_1.dat")) if "Raster" not in i])
EDAssert.strAlmostEqual(asciiRef, asciiObt, _strComment="3 column ascii files are the same", _fRelError=0.1, _strExcluded=os.environ["USER"])
EDVerbose.screen("Execution time for %s: %.3fs" % (plugin.getClassName(), plugin.getRunTime()))
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsProcessOneFilev1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare dictionary
################################################################################
obtFile = xsDataResultObtained.integratedImage.path.value
refFile = os.path.join(self.getTestsDataImagesHome(), "bioSaxsProcessIntegrated.edf")
EDVerbose.DEBUG("fileRef=%s fileObt=%s" % (refFile, obtFile))
edfRef = openimage(refFile)
edfObt = openimage(obtFile)
headerRef = edfRef.header
headerObt = edfObt.header
keysRef = headerRef.keys()
keysObt = headerObt.keys()
keysRef.sort()
keysObt.sort()
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dict")
for key in keysRef:
if not (key.startswith("History") or key in [ "Compression", "DDummy", "Dummy", "EDF_HeaderSize", "HeaderID", "Image", "filename", "RasterOrientation"]):
EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfRef.data
referenceData = edfObt.data
EDAssert.arraySimilar(numpy.maximum(outputData, 0), numpy.maximum(referenceData, 0) , _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
outputData = edfRef.next().data
referenceData = edfObt.next().data
EDAssert.arraySimilar(numpy.maximum(outputData, 0), numpy.maximum(referenceData, 0) , _fScaledMaxDelta=0.05, _strComment="Images-ESD are the same")
################################################################################
# Compare Ascii files
################################################################################
asciiObt = os.linesep.join([i.strip() for i in open(xsDataResultObtained.integratedCurve.path.value) if "Raster" not in i])
asciiRef = os.linesep.join([i.strip() for i in open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsProcessIntegrated1_1.dat")) if "Raster" not in i])
EDAssert.strAlmostEqual(asciiRef, asciiObt, _strComment="3 column ascii files are the same", _fRelError=0.1, _strExcluded=os.environ["USER"])
EDVerbose.screen("Execution time for %s: %.3fs" % (plugin.getClassName(), plugin.getRunTime()))
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsMetadatav1_0.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same",
_strExcluded="bioSaxs")
################################################################################
# Compare dictionary:
################################################################################
edfRef = EdfFile.EdfFile(
xsDataResultObtained.getOutputImage().getPath().value)
edfObt = EdfFile.EdfFile(
os.path.join(self.getTestsDataImagesHome(), "bioSaxsMetadata.edf"))
########################################################################
# DEPRECATED PLUGIN => DEPREFCATED TESTS
########################################################################
# headerRef = edfRef.GetHeader(0)
# headerObt = edfObt.GetHeader(0)
# keysRef = headerRef.keys()
# keysObt = headerObt.keys()
# keysRef.sort()
# keysObt.sort()
# for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "Center_1", "Center_2", "Code", "Comments", "Concentration",
# "VersionNumber",'time_of_day', ]:
# if key in keysObt: keysObt.remove(key)
# if key in keysRef: keysRef.remove(key)
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary")
# for key in keysRef:
# EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfObt.GetData(0)
referenceData = edfRef.GetData(0)
EDAssert.arraySimilar(outputData,
referenceData,
_fAbsMaxDelta=0.1,
_fScaledMaxDelta=0.05,
_strComment="Images-data are the same")
def testExecute(self):
"""
"""
self.run()
xsdout = self.getPlugin().getDataOutput().marshal()
print self.getReferenceDataOutputFile()
xsdRef = XSDataResultStitchOffsetedImage.parseString(self.readAndParseFile(self.getReferenceDataOutputFile())).marshal()
EDAssert.strAlmostEqual(xsdRef, xsdout, "Xsd are the same")
# fabio.edfimage.edfimage(data=fabio.open(self.outFile).data - fabio.open(self.refFile).data).write("/tmp/delta.edf")
EDAssert.arraySimilar(fabio.open(self.outFile).data, fabio.open(self.refFile).data, "Arrays are the same", _fAbsMaxDelta=1)
def unitTestXsdToArray(self):
"""
test the execution of xsDataToArray static method
"""
EDVerbose.DEBUG("EDTestCaseEDUtilsArray.unitTestXsdToArray")
if numpy is not None:
EDAssert.arraySimilar(self.arrayNumpy,
EDUtilsArray.xsDataToArray(self.xsDataArrayNumpy, _bForceNoNumpy=False),
_strComment="Array are the same (Numpy used)")
else:
EDAssert.equal(self.arrayNoNumpy,
EDUtilsArray.xsDataToArray(self.xsDataArrayNumpy, _bCheckMd5sum=True, _bForceNoNumpy=False),
"Array are the same (no Numpy available)")
def testExecute(self):
"""
"""
self.run()
xsdout = self.getPlugin().getDataOutput().marshal()
print self.getReferenceDataOutputFile()
xsdRef = XSDataResultStitchOffsetedImage.parseString(
self.readAndParseFile(
self.getReferenceDataOutputFile())).marshal()
EDAssert.strAlmostEqual(xsdRef, xsdout, "Xsd are the same")
# fabio.edfimage.edfimage(data=fabio.open(self.outFile).data - fabio.open(self.refFile).data).write("/tmp/delta.edf")
EDAssert.arraySimilar(fabio.open(self.outFile).data,
fabio.open(self.refFile).data,
"Arrays are the same",
_fAbsMaxDelta=1)
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsAveragev1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare spectrum ascii Files
################################################################################
outputData = open(xsDataResultObtained.getAveragedCurve().getPath().value, "rb").read()
referenceData = open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsAveraged.dat"), "rb").read()
EDAssert.strAlmostEqual(referenceData, outputData, _strComment="3-column ascii spectra files spectra are the same", _fRelError=0.1, _fAbsError=0.1, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
edfObt = EdfFile.EdfFile(xsDataResultObtained.getAveragedImage().getPath().value)
edfRef = EdfFile.EdfFile(os.path.join(self.getTestsDataImagesHome(), "bioSaxsAveraged.edf"))
outputData = edfObt.GetData(0)
referenceData = edfRef.GetData(0)
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Averaged images are the same")
headerRef = edfRef.GetHeader(0)
headerObt = edfObt.GetHeader(0)
keysRef = headerRef.keys()
keysObt = headerObt.keys()
keysRef.sort()
keysObt.sort()
for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "History-1", "History-1~1" ]:
if key in keysObt: keysObt.remove(key)
if key in keysRef: keysRef.remove(key)
EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary for Corrected Images")
for key in keysRef:
EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value in Averaged %s are the same" % key, _strExcluded="bioSaxs")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsAveragev1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare spectrum ascii Files
################################################################################
outputData = open(xsDataResultObtained.getAveragedCurve().getPath().value, "rb").read()
referenceData = open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsAveraged.dat"), "rb").read()
EDAssert.strAlmostEqual(referenceData, outputData, _strComment="3-column ascii spectra files spectra are the same", _fRelError=0.1, _fAbsError=0.1, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
edfObt = EdfFile.EdfFile(xsDataResultObtained.getAveragedImage().getPath().value)
edfRef = EdfFile.EdfFile(os.path.join(self.getTestsDataImagesHome(), "bioSaxsAveraged.edf"))
outputData = edfObt.GetData(0)
referenceData = edfRef.GetData(0)
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Averaged images are the same")
headerRef = edfRef.GetHeader(0)
headerObt = edfObt.GetHeader(0)
keysRef = headerRef.keys()
keysObt = headerObt.keys()
keysRef.sort()
keysObt.sort()
for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "History-1", "History-1~1" ]:
if key in keysObt: keysObt.remove(key)
if key in keysRef: keysRef.remove(key)
EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary for Corrected Images")
for key in keysRef:
EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value in Averaged %s are the same" % key, _strExcluded="bioSaxs")
def testSpatialDistortion(self):
strRefX = "spline-3-18x.edf"
strRefY = "spline-3-18y.edf"
self.loadTestImage([strRefX, strRefY])
edPluginSPD = self.createPlugin()
strXMLInput = EDUtilsFile.readFileAndParseVariables(
self.strReferenceInputFileName)
xsDataInputSPDCake = XSDataInputSPDCake.parseString(strXMLInput)
edPluginSPD.setDataInput(xsDataInputSPDCake)
edPluginSPD.configure()
edPluginSPD.getInputParameter()
########################################################################
# Enforce some values
########################################################################
edPluginSPD.dictGeometry["SpatialDistortionFile"] = os.path.join(
self.getTestsDataImagesHome(),
"frelon_spline_file_to_correct_SPD.spline")
edPluginSPD.dictGeometry["TiltRotation"] = 18
edPluginSPD.dictGeometry["AngleOfTilt"] = 3
spline = Spline()
spline.read(edPluginSPD.dictGeometry["SpatialDistortionFile"])
edPluginSPD.dictGeometry["PixelSizeX"], edPluginSPD.dictGeometry[
"PixelSizeY"] = spline.getPixelSize()
edPluginSPD.createDisplacementMatrix(spline)
edPluginSPD.cleanDispMat(edPluginSPD.getWorkingDirectory())
refX = fabio.openimage.openimage(
os.path.join(self.getTestsDataImagesHome(), strRefX)).data
obtX = fabio.openimage.openimage(
os.path.join(
edPluginSPD.getWorkingDirectory(),
"frelon_spline_file_to_correct_SPD-tilted-x.edf")).data
refY = fabio.openimage.openimage(
os.path.join(self.getTestsDataImagesHome(), strRefY)).data
obtY = fabio.openimage.openimage(
os.path.join(
edPluginSPD.getWorkingDirectory(),
"frelon_spline_file_to_correct_SPD-tilted-y.edf")).data
# print edPluginSPD.dictGeometry
EDAssert.arraySimilar(obtX,
refX,
_fAbsMaxDelta=0.1,
_strComment="X displacement Matrix is the same")
EDAssert.arraySimilar(obtY,
refY,
_fAbsMaxDelta=0.1,
_strComment="Y displacement Matrix is the same")
def testExecute(self):
self.run()
plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultSaxsAddv1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same")
outputData = openimage(xsDataResultObtained.getOutputImage().getPath().getValue()).data
referenceData = openimage(os.path.join(self.getTestsDataImagesHome(), "bsa_014_07.msk")).data
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.8, _fScaledMaxDelta=0.05, _fRfactor=5, _fRelMaxDelta=1.5 , _strComment="Images are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsMetadatav1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare dictionary:
################################################################################
edfRef = EdfFile.EdfFile(xsDataResultObtained.getOutputImage().getPath().value)
edfObt = EdfFile.EdfFile(os.path.join(self.getTestsDataImagesHome(), "bioSaxsMetadata.edf"))
########################################################################
# DEPRECATED PLUGIN => DEPREFCATED TESTS
########################################################################
# headerRef = edfRef.GetHeader(0)
# headerObt = edfObt.GetHeader(0)
# keysRef = headerRef.keys()
# keysObt = headerObt.keys()
# keysRef.sort()
# keysObt.sort()
# for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "Center_1", "Center_2", "Code", "Comments", "Concentration",
# "VersionNumber",'time_of_day', ]:
# if key in keysObt: keysObt.remove(key)
# if key in keysRef: keysRef.remove(key)
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary")
# for key in keysRef:
# EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfObt.GetData(0)
referenceData = edfRef.GetData(0)
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsNormalizev1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare dictionary
################################################################################
edfRef = openimage(xsDataResultObtained.normalizedImage.getPath().value)
edfObt = openimage(os.path.join(self.getTestsDataImagesHome(), "bioSaxsCorrected.edf"))
headerRef = edfRef.header
headerObt = edfObt.header
keysRef = headerRef.keys()
keysObt = headerObt.keys()
keysRef.sort()
keysObt.sort()
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dict")
for key in keysRef:
if not (key.startswith("History") or key in [ "Compression", "DDummy", "Dummy", "EDF_HeaderSize", "HeaderID", "Image", "filename", "RasterOrientation", "time_of_day"]):
EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfRef.data
referenceData = edfObt.data
EDAssert.arraySimilar(numpy.maximum(outputData, 0), numpy.maximum(referenceData, 0) , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
outputData = edfRef.next().data
referenceData = edfObt.next().data
EDAssert.arraySimilar(numpy.maximum(outputData, 0), numpy.maximum(referenceData, 0) , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-ESD are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
# # Checking obtained results
xsDataResultsSPDCake = plugin.getDataOutput()
pathToOutput = xsDataResultsSPDCake.getCakedFile().getPath().getValue()
# edStringDataObtained = EDUtilsFile.readFile(pathToOutput)
# edStringDataReference = EDUtilsFile.readFile(os.path.join(self.getPluginTestsDataHome(), \
# "EDPluginSPDCakev1_1.chi"))
# EDAssert.strAlmostEqual(edStringDataReference, edStringDataObtained, "Comparing ChiPlot files")
EDVerbose.DEBUG("Checking obtained result...")
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
xsDataResultReference = XSDataResultSPDCake.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same")
# Checking obtained results
xsDataResultsSPDCake = plugin.getDataOutput()
strPathToChiOutput = xsDataResultsSPDCake.getCakedFile().getPath(
).getValue()
strPathToChiReference = os.path.join(self.getTestsDataImagesHome(),
"EDPluginSPDCakev1_1.chi")
Xref, Yref = readChiPlot(strPathToChiReference)
Xobt, Yobt = readChiPlot(strPathToChiOutput)
EDVerbose.DEBUG("Output File: %s, Reference file: %s" %
(strPathToChiOutput, strPathToChiReference))
bigX = Xref + Xobt
bigX.sort()
bigYobt = numpy.interp(bigX, Xobt, Yobt)
bigYref = numpy.interp(bigX, Xref, Yref)
EDVerbose.DEBUG("ref.shape= %s, obt.shape=%s" %
(bigYobt.shape, bigYref.shape))
EDVerbose.DEBUG("Type of object ref= %s, obt=%s" %
(bigYobt.__class__, bigYref.__class__))
EDAssert.arraySimilar(bigYobt,
bigYref,
_fAbsMaxDelta=0.1,
_fScaledMaxDelta=0.1,
_strComment="Comparing ChiPlot files")
def testExecute(self):
"""
"""
self.run()
# plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultNormalize.parseString(strExpectedOutput)
xsDataResultObtained = XSDataResultNormalize.parseString(strObtainedOutput)
#EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "Result XML are the same")
npaReference = EDUtilsArray.xsDataToArray(xsDataResultReference.output.array)
npaObtained = EDUtilsArray.xsDataToArray(xsDataResultObtained.output.array)
EDAssert.arraySimilar(npaReference, npaObtained, "Arrays are the same", _fAbsMaxDelta=1e-6)
EDAssert.equal(npaReference.dtype, npaObtained.dtype, "Datatypes are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultSaxsAnglev1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same")
outputData = openimage(xsDataResultObtained.getRegroupedDataFile().getPath().getValue()).data
referenceData = openimage(os.path.join(self.getTestsDataImagesHome(), "Moke-2th10-tilt0-rot0.azim")).data
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.4, _fScaledMaxDelta=0.5, _strComment="Images are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsMetadatav1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare dictionary
################################################################################
edfRef = fabio.open(xsDataResultObtained.getOutputImage().getPath().value)
edfObt = fabio.open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsMetadata.edf"))
keysRef = edfRef.header_keys
keysObt = edfObt.header_keys
keysRef.sort()
keysObt.sort()
for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation" ]:
if key in keysObt: keysObt.remove(key)
if key in keysRef: keysRef.remove(key)
# print edfObt.header
EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary")
for key in keysRef:
EDAssert.strAlmostEqual(edfRef.header[key], edfObt.header[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfObt.data
referenceData = edfRef.data
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
def testExecute(self):
"""
"""
self.run()
# Checks that there are no error messages
plugin = self.getPlugin()
# EDVerbose.DEBUG("Checking error messages...")
# EDAssert.equal(self.m_iNoErrorMessages, self.getErrorMessages().getNumberObjects())
#
# EDVerbose.DEBUG("Checking warning messages...")
# EDAssert.equal(self.m_iNoWarningMessages, self.getWarningMessages().getNumberObjects())
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultExecThumbnail.parseString(strExpectedOutput)
xsDataResultObtained = XSDataResultExecThumbnail.parseString(strObtainedOutput)
EDAssert.equal(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XML are the same")
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
xsDataResultReference = XSDataResultExecThumbnail.parseString(strExpectedOutput)
outputFileName = xsDataResultReference.getThumbnailPath().getPath().getValue()
outputImage = Image.open(outputFileName)
referenceFileName = os.path.join(self.getPluginTestsDataHome(), os.path.basename(outputFileName))
referenceImage = Image.open(referenceFileName)
# print (numpy.asarray(outputImage) - numpy.asarray(referenceImage))
# print (numpy.asarray(outputImage) - numpy.asarray(referenceImage)).max()
# print (numpy.asarray(outputImage) - numpy.asarray(referenceImage)).min()
# print numpy.asarray(outputImage).shape
# print numpy.asarray(referenceImage).shape
# from fabio.edfimage import edfimage
# edfimage(numpy.asarray(outputImage) - numpy.asarray(referenceImage)).write("/tmp/toto.edf", force_type=numpy.asarray(outputImage).dtype)
EDAssert.arraySimilar(numpy.asarray(outputImage), numpy.asarray(referenceImage), _strComment="Images are the same", _fAbsMaxDelta=5)
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile(self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultMatrixInvertv2.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(
xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
_fStrSimilar=0.99,
_strComment="XSDataResult output are the same",
)
output = fabio.open(self.outputFile).data
ref = fabio.open(os.path.join(self.getTestsDataImagesHome(), "inverted.edf")).data
EDAssert.arraySimilar(output, ref, "arrays are the same", 1e-4)
def testExecute(self):
"""
"""
self.run()
# Checks that there are no error messages
plugin = self.getPlugin()
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
strObtainedOutput = self.readAndParseFile(
self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultExecThumbnail.parseString(
strExpectedOutput)
xsDataResultObtained = XSDataResultExecThumbnail.parseString(
strObtainedOutput)
EDAssert.equal(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(), "XML are the same")
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
xsDataResultReference = XSDataResultExecThumbnail.parseString(
strExpectedOutput)
outputFileName = xsDataResultReference.getThumbnailPath().getPath(
).getValue()
outputImage = Image.open(outputFileName)
self.loadTestImage([os.path.basename(outputFileName)])
referenceFileName = os.path.join(EDUtilsPath.EDNA_TESTIMAGES,
os.path.basename(outputFileName))
referenceImage = Image.open(referenceFileName)
EDAssert.arraySimilar(numpy.asarray(outputImage),
numpy.asarray(referenceImage),
_strComment="Images are the same",
_fAbsMaxDelta=5)
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultMatrixInvertv2.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
_fStrSimilar=0.99,
_strComment="XSDataResult output are the same")
output = fabio.open(self.outputFile).data
ref = fabio.open(
os.path.join(self.getTestsDataImagesHome(), "inverted.edf")).data
EDAssert.arraySimilar(output, ref, "arrays are the same", 1e-4)
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile(self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultMatrixInvertFile.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(
xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
_strComment="XSDataResult output are the same",
)
################################################################################
# Check that outputData * inputData - Id = 0
################################################################################
outputData = openimage(self.outputFile).data
size = outputData.shape[0]
inputData = openimage(self.inputFile).data
EDAssert.arraySimilar(
numpy.matrix(outputData) * numpy.matrix(inputData),
numpy.identity(size),
_fAbsMaxDelta=2e-4,
_strComment="output x input = Id ",
)
################################################################################
# Compare image Files
################################################################################
referenceData = openimage(os.path.join(self.getTestsDataImagesHome(), os.path.basename(self.outputFile))).data
EDAssert.arraySimilar(referenceData, outputData, _fAbsMaxDelta=1e-5, _strComment="images are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsNormalizev1_0.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same",
_strExcluded="bioSaxs")
################################################################################
# Compare dictionary
################################################################################
edfRef = openimage(
xsDataResultObtained.normalizedImage.getPath().value)
edfObt = openimage(
os.path.join(self.getTestsDataImagesHome(),
"bioSaxsCorrected.edf"))
headerRef = edfRef.header
headerObt = edfObt.header
keysRef = headerRef.keys()
keysObt = headerObt.keys()
keysRef.sort()
keysObt.sort()
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dict")
for key in keysRef:
if not (key.startswith("History") or key in [
"Compression", "DDummy", "Dummy", "EDF_HeaderSize",
"HeaderID", "Image", "filename", "RasterOrientation",
"time_of_day"
]):
EDAssert.strAlmostEqual(
headerRef[key],
headerObt[key],
_strComment="header value %s are the same" % key,
_strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfRef.data
referenceData = edfObt.data
EDAssert.arraySimilar(numpy.maximum(outputData, 0),
numpy.maximum(referenceData, 0),
_fAbsMaxDelta=0.1,
_fScaledMaxDelta=0.05,
_strComment="Images-data are the same")
outputData = edfRef.next().data
referenceData = edfObt.next().data
EDAssert.arraySimilar(numpy.maximum(outputData, 0),
numpy.maximum(referenceData, 0),
_fAbsMaxDelta=0.1,
_fScaledMaxDelta=0.05,
_strComment="Images-ESD are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsAzimutIntv1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare spectrum ascii Files
################################################################################
outputData = open(xsDataResultObtained.getIntegratedCurve().getPath().value, "rb").read().split(os.linesep)
referenceData = EDUtilsFile.readFileAndParseVariables(os.path.join(self.getTestsDataImagesHome(), "bioSaxsIntegratedv1_1.dat"), EDUtilsPath.getDictOfPaths()).split(os.linesep)
outputData = os.linesep.join([i for i in outputData if not (i.startswith("# History") or i.startswith("# Raster"))])
referenceData = os.linesep.join([i for i in referenceData if not (i.startswith("# History") or i.startswith("# Raster")) ])
EDAssert.strAlmostEqual(referenceData, outputData, _strComment="3column ascii spectra files are the same", _fRelError=0.1, _fAbsError=0.1, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
# edfObt = EdfFile.EdfFile(xsDataResultObtained.getCorrectedImage().getPath().value)
# edfRef = EdfFile.EdfFile(os.path.join(self.getTestsDataImagesHome(), "bioSaxsCorrected.edf"))
# outputData = edfObt.GetData(0)
# referenceData = edfRef.GetData(0)
# EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Corrected images are the same")
# headerRef = edfRef.GetHeader(0)
# headerObt = edfObt.GetHeader(0)
# keysRef = headerRef.keys()
# keysObt = headerObt.keys()
# keysRef.sort()
# keysObt.sort()
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary for Corrected Images")
# for key in keysRef:
# EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value in Corrected %s are the same" % key, _strExcluded="bioSaxs")
edfObt = EdfFile.EdfFile(os.path.join(self.getTestsDataImagesHome(), "bioSaxsIntegrated.edf"))
edfRef = EdfFile.EdfFile(xsDataResultObtained.getIntegratedImage().getPath().value)
outputData = edfObt.GetData(0)
referenceData = edfRef.GetData(0)
EDAssert.arraySimilar(outputData, referenceData , _fScaledMaxDelta=0.05, _strComment="Integrated images are the same")
headerRef = edfRef.GetHeader(0)
headerObt = edfObt.GetHeader(0)
keysRef = headerRef.keys()
keysObt = headerObt.keys()
keysRef.sort()
keysObt.sort()
for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "History-1", "History-1~1", "History-2" ]:
if key in keysObt: keysObt.remove(key)
if key in keysRef: keysRef.remove(key)
EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary for Integrated Images")
for key in keysRef:
EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value in Integrated %s are the same" % key, _strExcluded="bioSaxs")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile (self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsNormalizev1_0.parseString(strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(), xsDataResultObtained.marshal(), "XSDataResult output are the same", _strExcluded="bioSaxs")
################################################################################
# Compare Log Files
################################################################################
outputData = ""
for oneLine in open(xsDataResultObtained.getLogFile().getPath().value, "rb").readlines():
oneline = oneLine.lower()
if oneline.startswith("first"):outputData += oneLine
if oneline.startswith("last"):outputData += oneLine
if oneline.startswith("increment"):outputData += oneLine
if oneline.startswith("factor"):outputData += oneLine
if oneline.startswith("constant"):outputData += oneLine
referenceData = ""
for oneLine in open(os.path.join(self.getTestsDataImagesHome(), "bioSaxsNormalized.log"), "rb").readlines():
oneline = oneLine.lower()
if oneline.startswith("first"):referenceData += oneLine
elif oneline.startswith("last"):referenceData += oneLine
elif oneline.startswith("increment"):referenceData += oneLine
elif oneline.startswith("factor"):referenceData += oneLine
elif oneline.startswith("constant"):referenceData += oneLine
EDAssert.strAlmostEqual(referenceData, outputData, _strComment="LogFiles are the same", _fAbsError=0.1)
################################################################################
# Compare dictionary
################################################################################
edfRef = EdfFile.EdfFile(xsDataResultObtained.normalizedImage.getPath().value)
edfObt = EdfFile.EdfFile(os.path.join(self.getTestsDataImagesHome(), "bioSaxsNormalized.edf"))
########################################################################
# Deprected plugin => deprected test
########################################################################
# headerRef = edfRef.GetHeader(0)
# headerObt = edfObt.GetHeader(0)
# keysRef = headerRef.keys()
# keysObt = headerObt.keys()
# keysRef.sort()
# keysObt.sort()
# for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "time_of_day" ]:
# if key in keysObt: keysObt.remove(key)
# if key in keysRef: keysRef.remove(key)
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dict")
# for key in keysRef:
# if not key.startswith("History"):
# EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfRef.GetData(0)
referenceData = edfObt.GetData(0)
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-data are the same")
outputData = edfRef.GetData(1)
referenceData = edfObt.GetData(1)
EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Images-ESD are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsNormalizev1_0.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same",
_strExcluded="bioSaxs")
################################################################################
# Compare Log Files
################################################################################
outputData = ""
for oneLine in open(xsDataResultObtained.getLogFile().getPath().value,
"rb").readlines():
oneline = oneLine.lower()
if oneline.startswith("first"): outputData += oneLine
if oneline.startswith("last"): outputData += oneLine
if oneline.startswith("increment"): outputData += oneLine
if oneline.startswith("factor"): outputData += oneLine
if oneline.startswith("constant"): outputData += oneLine
referenceData = ""
for oneLine in open(
os.path.join(self.getTestsDataImagesHome(),
"bioSaxsNormalized.log"), "rb").readlines():
oneline = oneLine.lower()
if oneline.startswith("first"): referenceData += oneLine
elif oneline.startswith("last"): referenceData += oneLine
elif oneline.startswith("increment"): referenceData += oneLine
elif oneline.startswith("factor"): referenceData += oneLine
elif oneline.startswith("constant"): referenceData += oneLine
EDAssert.strAlmostEqual(referenceData,
outputData,
_strComment="LogFiles are the same",
_fAbsError=0.1)
################################################################################
# Compare dictionary
################################################################################
edfRef = EdfFile.EdfFile(
xsDataResultObtained.normalizedImage.getPath().value)
edfObt = EdfFile.EdfFile(
os.path.join(self.getTestsDataImagesHome(),
"bioSaxsNormalized.edf"))
########################################################################
# Deprected plugin => deprected test
########################################################################
# headerRef = edfRef.GetHeader(0)
# headerObt = edfObt.GetHeader(0)
# keysRef = headerRef.keys()
# keysObt = headerObt.keys()
# keysRef.sort()
# keysObt.sort()
# for key in ["HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID", "EDF_HeaderSize", "filename", "RasterOrientation", "time_of_day" ]:
# if key in keysObt: keysObt.remove(key)
# if key in keysRef: keysRef.remove(key)
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dict")
# for key in keysRef:
# if not key.startswith("History"):
# EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value %s are the same" % key, _strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
outputData = edfRef.GetData(0)
referenceData = edfObt.GetData(0)
EDAssert.arraySimilar(outputData,
referenceData,
_fAbsMaxDelta=0.1,
_fScaledMaxDelta=0.05,
_strComment="Images-data are the same")
outputData = edfRef.GetData(1)
referenceData = edfObt.GetData(1)
EDAssert.arraySimilar(outputData,
referenceData,
_fAbsMaxDelta=0.1,
_fScaledMaxDelta=0.05,
_strComment="Images-ESD are the same")
def testExecute(self):
"""
"""
self.run()
plugin = self.getPlugin()
################################################################################
# Compare XSDataResults
################################################################################
strExpectedOutput = self.readAndParseFile(
self.getReferenceDataOutputFile())
# strObtainedOutput = self.readAndParseFile (self.m_edObtainedOutputDataFile)
EDVerbose.DEBUG("Checking obtained result...")
xsDataResultReference = XSDataResultBioSaxsAzimutIntv1_0.parseString(
strExpectedOutput)
xsDataResultObtained = plugin.getDataOutput()
EDAssert.strAlmostEqual(xsDataResultReference.marshal(),
xsDataResultObtained.marshal(),
"XSDataResult output are the same",
_strExcluded="bioSaxs")
################################################################################
# Compare spectrum ascii Files
################################################################################
outputData = open(
xsDataResultObtained.getIntegratedCurve().getPath().value,
"rb").read().split(os.linesep)
referenceData = EDUtilsFile.readFileAndParseVariables(
os.path.join(self.getTestsDataImagesHome(),
"bioSaxsIntegratedv1_1.dat"),
EDUtilsPath.getDictOfPaths()).split(os.linesep)
outputData = os.linesep.join([
i for i in outputData
if not (i.startswith("# History") or i.startswith("# Raster"))
])
referenceData = os.linesep.join([
i for i in referenceData
if not (i.startswith("# History") or i.startswith("# Raster"))
])
EDAssert.strAlmostEqual(
referenceData,
outputData,
_strComment="3column ascii spectra files are the same",
_fRelError=0.1,
_fAbsError=0.1,
_strExcluded="bioSaxs")
################################################################################
# Compare images
################################################################################
# edfObt = EdfFile.EdfFile(xsDataResultObtained.getCorrectedImage().getPath().value)
# edfRef = EdfFile.EdfFile(os.path.join(self.getTestsDataImagesHome(), "bioSaxsCorrected.edf"))
# outputData = edfObt.GetData(0)
# referenceData = edfRef.GetData(0)
# EDAssert.arraySimilar(outputData, referenceData , _fAbsMaxDelta=0.1, _fScaledMaxDelta=0.05, _strComment="Corrected images are the same")
# headerRef = edfRef.GetHeader(0)
# headerObt = edfObt.GetHeader(0)
# keysRef = headerRef.keys()
# keysObt = headerObt.keys()
# keysRef.sort()
# keysObt.sort()
# EDAssert.equal(keysRef, keysObt, _strComment="Same keys in the header dictionary for Corrected Images")
# for key in keysRef:
# EDAssert.strAlmostEqual(headerRef[key], headerObt[key], _strComment="header value in Corrected %s are the same" % key, _strExcluded="bioSaxs")
edfObt = EdfFile.EdfFile(
os.path.join(self.getTestsDataImagesHome(),
"bioSaxsIntegrated.edf"))
edfRef = EdfFile.EdfFile(
xsDataResultObtained.getIntegratedImage().getPath().value)
outputData = edfObt.GetData(0)
referenceData = edfRef.GetData(0)
EDAssert.arraySimilar(outputData,
referenceData,
_fScaledMaxDelta=0.05,
_strComment="Integrated images are the same")
headerRef = edfRef.GetHeader(0)
headerObt = edfObt.GetHeader(0)
keysRef = headerRef.keys()
keysObt = headerObt.keys()
keysRef.sort()
keysObt.sort()
for key in [
"HeaderID", "Image", 'EDF_BinarySize', "EDF_DataBlockID",
"EDF_HeaderSize", "filename", "RasterOrientation", "History-1",
"History-1~1", "History-2"
]:
if key in keysObt: keysObt.remove(key)
if key in keysRef: keysRef.remove(key)
EDAssert.equal(
keysRef,
keysObt,
_strComment=
"Same keys in the header dictionary for Integrated Images")
for key in keysRef:
EDAssert.strAlmostEqual(
headerRef[key],
headerObt[key],
_strComment="header value in Integrated %s are the same" % key,
_strExcluded="bioSaxs")
