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()) # 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 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")