├── Align ├── CAlignBase.cpp ├── CAlignInc.h ├── CAlignMain.cpp ├── CAlignParam.cpp ├── CAlignStack.cpp ├── CAlignedSum.cpp ├── CCorrFFTStack.cpp ├── CDetectFeatures.cpp ├── CEarlyMotion.cpp ├── CExtractPatch.cpp ├── CFullAlign.cpp ├── CGenXcfStack.cpp ├── CGroupFFTStack.cpp ├── CInterpolateShift.cpp ├── CIterativeAlign.cpp ├── CLoadAlign.cpp ├── CMeasurePatches.cpp ├── CPatchAlign.cpp ├── CPatchCenters.cpp ├── CPatchShifts.cpp ├── CPeak2D.cpp ├── CSaveAlign.cpp ├── CSimpleSum.cpp ├── CStackShift.cpp ├── CTransformStack.cpp ├── CZbinStack.cpp ├── GCC2D.cu ├── GCorrelateSum2D.cu ├── GNormByStd2D.cu └── GNormByStd2D_bak.cu ├── BadPixel ├── CCorrectMain.cpp ├── CCorrectMain.h ├── CDetectMain.cpp ├── CDetectMain.h ├── CLocalCCMap.cpp ├── CTemplate.cpp ├── GCombineBadMap.cu ├── GCorrectBad.cu ├── GDetectHot.cu ├── GDetectPatch.cu ├── GLabelPatch.cu └── GLocalCC.cu ├── CBufferPool.cpp ├── CCheckFreeGpus.cpp ├── CGenStarFile.cpp ├── CGpuBuffer.cpp ├── CInput.cpp ├── CLoadRefs.cpp ├── CMain.cpp ├── CMainInc.h ├── CMotionCor3.cpp ├── CProcessThread.cpp ├── CSaveSerialCryoEM.cpp ├── CStackBuffer.cpp ├── Correct ├── CCorrectFullShift.cpp ├── CCorrectInc.h ├── CGenRealStack.cpp ├── GCorrectPatchShift.cu ├── GStretch.cu └── GWeightFrame.cu ├── DataUtil ├── CAlnSums.cpp ├── CCtfResult.cpp ├── CDataPackage.cpp ├── CDataUtilInc.h ├── CFmGroupParam.cpp ├── CFmIntParam.cpp ├── CMrcStack.cpp ├── CReadFmIntFile.cpp └── CStackFolder.cpp ├── EerUtil ├── CDecodeEerFrame.cpp ├── CEerUtilInc.h ├── CLoadEerFrames.cpp ├── CLoadEerHeader.cpp ├── CLoadEerMain.cpp ├── CRenderMrcStack.cpp ├── GAddRawFrame.cu ├── GDecodeEerFrame.cpp └── GDecodeEerFrame.cu ├── FindCtf ├── CCtfTheory.cpp ├── CFindCtf1D.cpp ├── CFindCtf2D.cpp ├── CFindCtfBase.cpp ├── CFindCtfHelp.cpp ├── CFindCtfInc.h ├── CFindCtfMain.cpp ├── CFindDefocus1D.cpp ├── CFindDefocus2D.cpp ├── CFullSpectrum.cpp ├── CFullSpectrum.o ├── CGenAvgSpectrum.cpp ├── CRescaleImage.cpp ├── CSaveCtfResults.cpp ├── GBackground1D.cu ├── GCalcCTF1D.cu ├── GCalcCTF2D.cu ├── GCalcSpectrum.cu ├── GCtfCC1D.cu ├── GCtfCC2D.cu ├── GRadialAvg.cu ├── GRemoveMean.cu ├── GRmBackground2D.cu └── GSpectralCC2D.cu ├── LICENSE.md ├── LibSrc ├── Include │ ├── Mrcfile │ │ └── CMrcFileInc.h │ └── Util │ │ ├── Util_CGMinimize.h │ │ ├── Util_DataFile.h │ │ ├── Util_FileName.h │ │ ├── Util_Folder.h │ │ ├── Util_LinEqs.h │ │ ├── Util_Number.h │ │ ├── Util_Powell.h │ │ ├── Util_String.h │ │ ├── Util_SwapByte.h │ │ ├── Util_Thread.h │ │ └── Util_Time.h ├── Lib │ ├── libmrcfile.a │ └── libutil.a ├── Mrcfile │ ├── App │ │ ├── CFindMrc.cpp │ │ ├── CLoadMrc.cpp │ │ ├── CMrcScale.cpp │ │ ├── CReviseExtHeader.cpp │ │ ├── CSaveMrc.cpp │ │ └── CVerticalFlip.cpp │ ├── Header │ │ ├── CLoadExtHeader.cpp │ │ ├── CLoadMainHeader.cpp │ │ ├── CMainHeader.cpp │ │ ├── CSaveExtHeader.cpp │ │ └── CSaveMainHeader.cpp │ ├── Image │ │ ├── C4BitImage.cpp │ │ ├── CLoadImage.cpp │ │ └── CSaveImage.cpp │ ├── Include │ │ └── CMrcFileInc.h │ └── makefile └── Util │ ├── Util_CGMinimize.cpp │ ├── Util_CGMinimize.h │ ├── Util_DataFile.cpp │ ├── Util_DataFile.h │ ├── Util_FileName.cpp │ ├── Util_FileName.h │ ├── Util_Folder.cpp │ ├── Util_Folder.h │ ├── Util_LinEqs.cpp │ ├── Util_LinEqs.h │ ├── Util_Number.cpp │ ├── Util_Number.h │ ├── Util_Powell.cpp │ ├── Util_Powell.h │ ├── Util_String.cpp │ ├── Util_String.h │ ├── Util_SwapByte.cpp │ ├── Util_SwapByte.h │ ├── Util_Thread.cpp │ ├── Util_Thread.h │ ├── Util_Time.cpp │ ├── Util_Time.h │ └── makefile ├── MotionDecon ├── CInFrameMotion.cpp ├── CMotionDeconInc.h ├── GDeconFrame.cu └── GMotionWeight.cu ├── MrcUtil ├── CAnalyzeMrc.cpp ├── CApplyGain.cpp ├── CApplyRefs.cpp ├── CAsyncSingleSave.cpp ├── CLoadCryoEMStack.cpp ├── CLoadStack.cpp ├── CMrcUtilInc.h ├── CSaveSingleCryoEM.cpp ├── CSumFFTStack.cpp ├── CTiltAngles.cpp ├── G4BitImage.cu ├── G90Rotate2D.cu ├── GApplyGainToFrame.cu ├── GApplyRefsToFrame.cu ├── GAugmentRef.cu ├── GFlip2D.cu └── GInverse2D.cu ├── README.md ├── Readme.txt ├── SECURITY.md ├── TestReadme.txt ├── TiffUtil ├── CLoadTiffHeader.cpp ├── CLoadTiffImage.cpp ├── CLoadTiffImage.cpp-bak ├── CLoadTiffImage.cpp-new ├── CLoadTiffStack.cpp ├── CTiffFileInc.h └── makefile ├── Util ├── CCufft2D.cpp ├── CFileName.cpp ├── CFlipImage.cpp ├── CFourierCrop2D.cpp ├── CGroupFrames.cpp ├── CMultiGpuBase.cpp ├── CNextItem.cpp ├── CPad2D.cpp ├── CParseArgs.cpp ├── CRemoveSpikes1D.cpp ├── CSaveTempMrc.cpp ├── CSimpleFuncs.cpp ├── CSplineFit1D.cpp ├── CUtilInc.h ├── GAddFrames.cu ├── GCalcMoment2D.cu ├── GCorrLinearInterp.cu ├── GFFT1D.cu ├── GFFTUtil2D.cu ├── GFindMinMax2D.cu ├── GFourierResize2D.cu ├── GFtResize2D.cu ├── GNormalize2D.cu ├── GPad2D.cu ├── GPartialCopy.cu ├── GPhaseShift2D.cu ├── GPositivity2D.cu ├── GRoundEdge.cu └── GThreshold2D.cu ├── docs └── ReadmeImg.png ├── makefile └── makefile11 /Align/CAlignBase.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include "../DataUtil/CDataUtilInc.h" 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace MotionCor2; 13 | using namespace MotionCor2::Align; 14 | namespace DU = MotionCor2::DataUtil; 15 | 16 | CAlignBase::CAlignBase(void) 17 | { 18 | m_pFullShift = 0L; 19 | } 20 | 21 | CAlignBase::~CAlignBase(void) 22 | { 23 | this->Clean(); 24 | } 25 | 26 | void CAlignBase::Clean(void) 27 | { 28 | if(m_pFullShift == 0L) return; 29 | delete m_pFullShift; 30 | m_pFullShift = 0L; 31 | } 32 | 33 | void CAlignBase::DoIt(DU::CDataPackage* pPackage) 34 | { 35 | nvtxRangePushA ("CAlignBase::DoIt"); 36 | //---------------------------------- 37 | m_pPackage = pPackage; 38 | CInput* pInput = CInput::GetInstance(); 39 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 40 | CStackBuffer* pFrmBuffer = pBufferPool->GetBuffer(EBuffer::frm); 41 | //-------------------------------------------------------------- 42 | Util::GFourierResize2D::GetBinnedCmpSize(pFrmBuffer->m_aiCmpSize, 43 | pInput->m_fFourierBin, m_aiCmpSize); 44 | //------------------------------------- 45 | m_aiImgSize[0] = (m_aiCmpSize[0] - 1) * 2; 46 | m_aiImgSize[1] = m_aiCmpSize[1]; 47 | m_aiPadSize[0] = m_aiCmpSize[0] * 2; 48 | m_aiPadSize[1] = m_aiCmpSize[1]; 49 | //------------------------------ 50 | mCreateAlnSums(); 51 | mCreateAlnStack(); 52 | nvtxRangePop(); 53 | } 54 | 55 | void CAlignBase::LogShift(char* pcLogFile) 56 | { 57 | } 58 | 59 | void CAlignBase::mCreateAlnSums(void) 60 | { 61 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 62 | int iNumSums = pBufferPool->m_iNumSums; 63 | int aiStkSize[] = {m_aiImgSize[0], m_aiImgSize[1], iNumSums}; 64 | //----------------- 65 | bool bCreatePkg = true; 66 | if(m_pPackage->m_pAlnSums != 0L) 67 | { int* piOldSize = m_pPackage->m_pAlnSums->m_aiStkSize; 68 | if(piOldSize[0] == m_aiImgSize[0] && 69 | piOldSize[1] == m_aiImgSize[1] && 70 | piOldSize[2] == iNumSums) return; 71 | } 72 | //----------------- 73 | if(m_pPackage->m_pAlnSums != 0L) 74 | { delete m_pPackage->m_pAlnSums; 75 | m_pPackage->m_pAlnSums = 0L; 76 | } 77 | DU::CAlnSums* pAlnSums = new DU::CAlnSums; 78 | pAlnSums->Create(Mrc::eMrcFloat, aiStkSize); 79 | m_pPackage->m_pAlnSums = pAlnSums; 80 | //----------------- 81 | DU::CFmIntParam* pFmIntParam = m_pPackage->m_pFmIntParam; 82 | pAlnSums->Setup(pFmIntParam->bDoseWeight(), 83 | pFmIntParam->bDWSelectedSum()); 84 | //----------------- 85 | CInput* pInput = CInput::GetInstance(); 86 | pAlnSums->m_fPixSize = pInput->GetFinalPixelSize(); 87 | } 88 | 89 | void CAlignBase::mCreateAlnStack(void) 90 | { 91 | CInput* pInput = CInput::GetInstance(); 92 | if(pInput->m_aiOutStack[0] == 0) return; 93 | //----------------- 94 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 95 | CStackBuffer* pFrmBuffer = pBufferPool->GetBuffer(EBuffer::frm); 96 | int iNumFrames = pFrmBuffer->m_iNumFrames; 97 | int aiStkSize[] = {m_aiImgSize[0], m_aiImgSize[1], iNumFrames}; 98 | //----------------- 99 | DataUtil::CMrcStack* pAlnStack = new DataUtil::CMrcStack; 100 | pAlnStack->Create(Mrc::eMrcFloat, aiStkSize); 101 | pAlnStack->m_fPixSize = pInput->GetFinalPixelSize(); 102 | m_pPackage->m_pAlnStack = pAlnStack; 103 | 104 | } 105 | -------------------------------------------------------------------------------- /Align/CAlignMain.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace MotionCor2; 12 | using namespace MotionCor2::Align; 13 | 14 | CAlignMain::CAlignMain(void) 15 | { 16 | m_pAlnSums = 0L; 17 | m_pAlnStack = 0L; 18 | } 19 | 20 | CAlignMain::~CAlignMain(void) 21 | { 22 | mClean(); 23 | } 24 | 25 | DataUtil::CAlnSums* CAlignMain::GetAlnSums(bool bClean) 26 | { 27 | DataUtil::CAlnSums* pAlnSums = m_pAlnSums; 28 | if(bClean) m_pAlnSums = 0L; 29 | return pAlnSums; 30 | } 31 | 32 | DataUtil::CMrcStack* CAlignMain::GetAlnStack(bool bClean) 33 | { 34 | DataUtil::CMrcStack* pAlnStack = m_pAlnStack; 35 | if(bClean) m_pAlnStack = 0L; 36 | return pAlnStack; 37 | } 38 | 39 | void CAlignMain::DoIt(DU::CDataPackage* pPackage) 40 | { 41 | nvtxRangePush ("CAlignMain::DoIt"); 42 | mClean(); 43 | m_pPackage = pPackage; 44 | //-------------------- 45 | CAlignBase* pAlignBase = 0L; 46 | CAlignParam* pAlignParam = CAlignParam::GetInstance(); 47 | //---------------------------------------------------- 48 | nvtxRangePushA("align select"); 49 | if(pAlignParam->SimpleSum()) 50 | { printf("Simple sum\n"); 51 | pAlignBase = new CSimpleSum; 52 | } 53 | else if(pAlignParam->PatchAlign()) 54 | { printf("Patch based alignment\n"); 55 | pAlignBase = new CPatchAlign; 56 | } 57 | else 58 | { printf("Full frame alignment\n"); 59 | pAlignBase = new CFullAlign; 60 | } 61 | nvtxRangePop(); 62 | pAlignBase->DoIt(pPackage); 63 | //------------------------- 64 | CZbinStack aZbinStack; 65 | aZbinStack.DoIt(pPackage); 66 | //------------------------ 67 | char* pcLogFile = mCreateLogFile(); 68 | if(pcLogFile != 0L) 69 | { pAlignBase->LogShift(pcLogFile); 70 | delete[] pcLogFile; 71 | } 72 | //-------------------------------------------- 73 | if(pAlignBase != 0L) delete pAlignBase; 74 | nvtxRangePop(); 75 | } 76 | 77 | char* CAlignMain::mCreateLogFile(void) 78 | { 79 | CInput* pInput = CInput::GetInstance(); 80 | if(0 == strlen(pInput->m_acLogDir)) return 0L; 81 | //-------------------------------------------- 82 | char* pcInFile = strrchr(m_pPackage->m_pcInFileName, '/'); 83 | if(pcInFile != 0L) pcInFile += 1; 84 | else pcInFile = m_pPackage->m_pcInFileName; 85 | //------------------------------------------------------ 86 | char* pcLogFile = new char[256]; 87 | strcpy(pcLogFile, pInput->m_acLogDir); 88 | strcat(pcLogFile, pcInFile); 89 | //------------------------------------ 90 | char* pcFileExt = strcasestr(pcLogFile, ".mrc"); 91 | if(pcFileExt != 0L) 92 | { strcpy(pcFileExt, ""); 93 | return pcLogFile; 94 | } 95 | pcFileExt = strcasestr(pcLogFile, ".tif"); 96 | if(pcFileExt != 0L) 97 | { strcpy(pcFileExt, ""); 98 | return pcLogFile; 99 | } 100 | pcFileExt = strcasestr(pcLogFile, ".eer"); 101 | if(pcFileExt != 0L) 102 | { strcpy(pcFileExt, ""); 103 | return pcLogFile; 104 | } 105 | //------------------------------------------------ 106 | delete pcLogFile; return 0L; 107 | } 108 | 109 | void CAlignMain::mClean(void) 110 | { 111 | if(m_pAlnStack != 0L) delete m_pAlnStack; 112 | m_pAlnStack = 0L; 113 | } 114 | -------------------------------------------------------------------------------- /Align/CAlignParam.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include "../CMainInc.h" 3 | #include 4 | #include 5 | 6 | using namespace MotionCor2; 7 | using namespace MotionCor2::Align; 8 | 9 | CAlignParam* CAlignParam::m_pInstance = 0L; 10 | 11 | CAlignParam* CAlignParam::GetInstance(void) 12 | { 13 | if(m_pInstance != 0L) return m_pInstance; 14 | m_pInstance = new CAlignParam; 15 | return m_pInstance; 16 | } 17 | 18 | void CAlignParam::DeleteInstance(void) 19 | { 20 | if(m_pInstance == 0L) return; 21 | delete m_pInstance; 22 | m_pInstance = 0L; 23 | } 24 | 25 | CAlignParam::CAlignParam(void) 26 | { 27 | } 28 | 29 | CAlignParam::~CAlignParam(void) 30 | { 31 | } 32 | 33 | bool CAlignParam::PhaseOnly(void) 34 | { 35 | CInput* pInput = CInput::GetInstance(); 36 | if(pInput->m_iPhaseOnly == 1) return true; 37 | else return false; 38 | } 39 | 40 | bool CAlignParam::SimpleSum(void) 41 | { 42 | CInput* pInput = CInput::GetInstance(); 43 | if(pInput->m_iAlign == 0) return true; 44 | else return false; 45 | } 46 | 47 | bool CAlignParam::CorrectMag(void) 48 | { 49 | float afStretch[2] = {1.0f, 0.0f}; 50 | this->GetMagStretch(afStretch); 51 | if(fabs(afStretch[0] - 1) < 1e-5) return false; 52 | else return true; 53 | } 54 | 55 | void CAlignParam::GetMagStretch(float* pfStretch) 56 | { 57 | //---------------------------------------------------- 58 | // mag_distortion_correct_1.0.0: 03/15/2017 59 | // 1. Its y-axis points downward. My y-axis points 60 | // upward. Therefore, the angle of major axis 61 | // is multiplied by -1. 62 | // 2. This is found by comparing the image with 63 | // mag corrected by MotionCor2 and the one 64 | // by mag_distortion_correct_1.0.0 using 65 | // major scale 1.5 and minor scale 1.0 66 | //---------------------------------------------------- 67 | CInput* pInput = CInput::GetInstance(); 68 | pfStretch[0] = pInput->m_afMag[0] / pInput->m_afMag[1]; 69 | pfStretch[1] = -1.0f * pInput->m_afMag[2]; 70 | printf("Mag stretch: %.3f %.3f\n\n", pfStretch[0], 71 | pfStretch[1]); 72 | } 73 | 74 | bool CAlignParam::PatchAlign(void) 75 | { 76 | CInput* pInput = CInput::GetInstance(); 77 | if(pInput->m_aiNumPatches[0] <= 1) return false; 78 | if(pInput->m_aiNumPatches[1] <= 1) return false; 79 | return true; 80 | } 81 | 82 | bool CAlignParam::SplitSum(void) 83 | { 84 | CInput* pInput = CInput::GetInstance(); 85 | if(pInput->m_iSplitSum == 0) return false; 86 | else return true; 87 | } 88 | 89 | int CAlignParam::GetNumPatches(void) 90 | { 91 | CInput* pInput = CInput::GetInstance(); 92 | int iPatches = pInput->m_aiNumPatches[0] 93 | * pInput->m_aiNumPatches[1]; 94 | return iPatches; 95 | } 96 | 97 | int CAlignParam::GetFrameRef(int iNumFrames) 98 | { 99 | CInput* pInput = CInput::GetInstance(); 100 | if(pInput->m_iFmRef < 0) return iNumFrames / 2; 101 | //--------------------------------------------- 102 | int iFrameRef = pInput->m_iFmRef - 1; 103 | if(iFrameRef < 0) iFrameRef = 0; 104 | else if(iFrameRef >= iNumFrames) iFrameRef = iNumFrames - 1; 105 | return iFrameRef; 106 | } 107 | 108 | -------------------------------------------------------------------------------- /Align/CCorrFFTStack.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include "../MrcUtil/CMrcUtilInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | using namespace MotionCor2; 11 | using namespace MotionCor2::Align; 12 | 13 | void CCorrFFTStack::DoIt 14 | ( MrcUtil::GFFTStack* pGFFTStack, 15 | CStackShift* pStackShift 16 | ) 17 | { Util::CNextItem nextItem; 18 | nextItem.Create(pGFFTStack->m_aiStkSize[2]); 19 | //------------------------------------------ 20 | int iNumGpus = pGFFTStack->GetNumGpus(); 21 | //-------------------------------------- 22 | CCorrFFTStack* pThreads = new CCorrFFTStack[iNumGpus]; 23 | for(int i=0; iGetGpuId(iThreadId); 51 | this->Start(); 52 | } 53 | 54 | void CCorrFFTStack::ThreadMain(void) 55 | { 56 | cudaSetDevice(m_iGpuId); 57 | //---------------------- 58 | mCorrGpuFrames(); 59 | mCorrCpuFrames(); 60 | } 61 | 62 | void CCorrFFTStack::mCorrGpuFrames(void) 63 | { 64 | float afShift[2] = {0}; 65 | for(int i=0; im_aiStkSize[2]; i++) 66 | { m_pStackShift->GetShift(i, afShift); 67 | if(afShift[0] == 0 && afShift[1] == 0) continue; 68 | //---------------------------------------------- 69 | int iGpuId = m_pGFFTStack->GetFrameGpu(i); 70 | if(iGpuId != m_iGpuId) continue; 71 | //------------------------------ 72 | m_pGFFTStack->Align(i, afShift); 73 | } 74 | } 75 | 76 | void CCorrFFTStack::mCorrCpuFrames(void) 77 | { 78 | float afShift[2] = {0.0f}; 79 | cufftComplex* gCmpBuf = (cufftComplex*)Util::GetGpuBuf 80 | ( m_pGFFTStack->m_aiCmpSize, sizeof(cufftComplex), false 81 | ); 82 | //------------------------------------------------------ 83 | while(true) 84 | { int i = m_pNextItem->GetNext(); 85 | if(i < 0) break; 86 | if(m_pGFFTStack->IsGpuFrame(i)) continue; 87 | //--------------------------------------- 88 | m_pStackShift->GetShift(i, afShift); 89 | if(afShift[0] == 0 && afShift[1] == 0) continue; 90 | //---------------------------------------------- 91 | m_pGFFTStack->Align(gCmpBuf, i, afShift); 92 | } 93 | if(gCmpBuf != 0L) cudaFree(gCmpBuf); 94 | } 95 | 96 | -------------------------------------------------------------------------------- /Align/CExtractPatch.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace MotionCor2; 12 | using namespace MotionCor2::Align; 13 | 14 | static CStackBuffer* s_pPatBuffer = 0L; 15 | static CStackBuffer* s_pXcfBuffer = 0L; 16 | static CStackBuffer* s_pSumBuffer = 0L; 17 | static int s_aiPatStart[2] = {0}; 18 | 19 | CExtractPatch::CExtractPatch(void) 20 | { 21 | } 22 | 23 | CExtractPatch::~CExtractPatch(void) 24 | { 25 | } 26 | 27 | void CExtractPatch::DoIt(int iPatch) 28 | { 29 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 30 | s_pPatBuffer = pBufferPool->GetBuffer(EBuffer::pat); 31 | s_pXcfBuffer = pBufferPool->GetBuffer(EBuffer::xcf); 32 | s_pSumBuffer = pBufferPool->GetBuffer(EBuffer::sum); 33 | //-------------------------------------------------- 34 | CPatchCenters* pPatchCenters = CPatchCenters::GetInstance(); 35 | pPatchCenters->GetStart(iPatch, s_aiPatStart); 36 | //-------------------------------------------- 37 | int iNumGpus = pBufferPool->m_iNumGpus; 38 | CExtractPatch* pExtractPatch = new CExtractPatch[iNumGpus]; 39 | for(int i=0; iSetDevice(m_iNthGpu); 52 | //--------------------------------- 53 | cudaStreamCreate(&m_aStream[0]); 54 | cudaStreamCreate(&m_aStream[1]); 55 | mProcessCpuFrames(); 56 | mProcessGpuFrames(); 57 | } 58 | 59 | void CExtractPatch::Wait(void) 60 | { 61 | s_pPatBuffer->SetDevice(m_iNthGpu); 62 | cudaStreamSynchronize(m_aStream[0]); 63 | cudaStreamSynchronize(m_aStream[1]); 64 | cudaStreamDestroy(m_aStream[0]); 65 | cudaStreamDestroy(m_aStream[1]); 66 | } 67 | 68 | void CExtractPatch::mProcessGpuFrames(void) 69 | { 70 | int iNumFrames = s_pPatBuffer->GetNumFrames(m_iNthGpu); 71 | for(int i=0; iIsGpuFrame(m_iNthGpu, i)) continue; 73 | mProcessFrame(i, m_aStream[0]); 74 | } 75 | } 76 | 77 | void CExtractPatch::mProcessCpuFrames(void) 78 | { 79 | int iCount = 0; 80 | int iNumFrames = s_pPatBuffer->GetNumFrames(m_iNthGpu); 81 | for(int i=0; iIsGpuFrame(m_iNthGpu, i)) continue; 83 | int iStream = iCount % 2; 84 | mProcessFrame(i, m_aStream[iStream]); 85 | iCount += 1; 86 | } 87 | } 88 | 89 | void CExtractPatch::mProcessFrame(int iFrame, cudaStream_t stream) 90 | { 91 | cufftComplex* gPatCmp = s_pPatBuffer->GetFrame(m_iNthGpu, iFrame); 92 | cufftComplex* gXcfCmp = s_pXcfBuffer->GetFrame(m_iNthGpu, iFrame); 93 | float* gfPatFrm = reinterpret_cast(gPatCmp); 94 | float* gfXcfFrm = reinterpret_cast(gXcfCmp); 95 | //-------------------------------------------------- 96 | int iXcfPadX = s_pXcfBuffer->m_aiCmpSize[0] * 2; 97 | int iOffset = s_aiPatStart[1] * iXcfPadX + s_aiPatStart[0]; 98 | float* gfSrc = gfXcfFrm + iOffset; 99 | //-------------------------------- 100 | int iCpySizeX = (s_pPatBuffer->m_aiCmpSize[0] - 1) * 2; 101 | int iPatPadX = s_pPatBuffer->m_aiCmpSize[0] * 2; 102 | int iPatPadY = s_pPatBuffer->m_aiCmpSize[1]; 103 | int aiPatPadSize[] = {iPatPadX, iPatPadY}; 104 | Util::GPartialCopy::DoIt(gfSrc, iXcfPadX, gfPatFrm, 105 | iCpySizeX, aiPatPadSize, stream); 106 | } 107 | 108 | -------------------------------------------------------------------------------- /Align/CMeasurePatches.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace MotionCor2; 12 | using namespace MotionCor2::Align; 13 | 14 | CMeasurePatches::CMeasurePatches(void) 15 | { 16 | } 17 | 18 | CMeasurePatches::~CMeasurePatches(void) 19 | { 20 | } 21 | 22 | void CMeasurePatches::DoIt 23 | ( DU::CDataPackage* pPackage, 24 | CPatchShifts* pPatchShifts 25 | ) 26 | { m_pPackage = pPackage; 27 | m_pPatchShifts = pPatchShifts; 28 | //------------------------------ 29 | CInput* pInput = CInput::GetInstance(); 30 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 31 | //---------------------------------------------------- 32 | float fBin = fmaxf(pBufferPool->m_afXcfBin[0], 33 | pBufferPool->m_afXcfBin[1]); 34 | m_fTol = pInput->m_fTolerance / fBin; 35 | m_bPhaseOnly = (pInput->m_iPhaseOnly == 0) ? false : true; 36 | //-------------------------------------------------------- 37 | int iNumPatches = pInput->m_aiNumPatches[0] 38 | * pInput->m_aiNumPatches[1]; 39 | for(int i=0; iMakeRelative(); 44 | m_pPatchShifts->DetectBads(); 45 | } 46 | 47 | void CMeasurePatches::mCalcPatchShift(int iPatch) 48 | { 49 | CInput* pInput = CInput::GetInstance(); 50 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 51 | CStackBuffer* pFrmBuffer = pBufferPool->GetBuffer(EBuffer::frm); 52 | CStackBuffer* pPatBuffer = pBufferPool->GetBuffer(EBuffer::pat); 53 | //-------------------------------------------------------------- 54 | bool bForward = true, bNorm = true; 55 | CTransformStack::DoIt(EBuffer::pat, bForward, !bNorm); 56 | //---------------------------------------------------- 57 | CStackShift* pPatShift = new CStackShift; 58 | pPatShift->Setup(pPatBuffer->m_iNumFrames); 59 | //----------------------------------------- 60 | CIterativeAlign iterAlign; 61 | iterAlign.Setup(EBuffer::pat, 62 | pInput->m_afBFactor[1], m_bPhaseOnly); 63 | iterAlign.DoIt(m_pPackage, pPatShift); 64 | //------------------------------------ 65 | int iNumPatches = pInput->m_aiNumPatches[0] 66 | * pInput->m_aiNumPatches[1]; 67 | char* pcErrLog = iterAlign.GetErrorLog(); 68 | int iLeft = iNumPatches - 1 - iPatch; 69 | printf("Align patch %d %d left\n%s\n", iPatch+1, iLeft, pcErrLog); 70 | if(pcErrLog != 0L) delete[] pcErrLog; 71 | //----------------------------------------------------------------- 72 | int aiCenter[2] = {0}; 73 | CPatchCenters* pPatchCenters = CPatchCenters::GetInstance(); 74 | pPatchCenters->GetCenter(iPatch, aiCenter); 75 | float fCentX = aiCenter[0] * pBufferPool->m_afXcfBin[0]; 76 | float fCentY = aiCenter[1] * pBufferPool->m_afXcfBin[1]; 77 | pPatShift->SetCenter(fCentX, fCentY); 78 | //----------------------------------- 79 | pPatShift->Multiply(pBufferPool->m_afXcfBin[0], 80 | pBufferPool->m_afXcfBin[1]); 81 | m_pPatchShifts->SetRawShift(pPatShift, iPatch); 82 | if(pPatShift != 0L) delete pPatShift; 83 | } 84 | 85 | -------------------------------------------------------------------------------- /Align/CPatchAlign.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include "../Correct/CCorrectInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace MotionCor2; 13 | using namespace MotionCor2::Align; 14 | 15 | CPatchAlign::CPatchAlign(void) 16 | { 17 | m_pPatchShifts = 0L; 18 | } 19 | 20 | CPatchAlign::~CPatchAlign(void) 21 | { 22 | if(m_pPatchShifts != 0L) delete m_pPatchShifts; 23 | } 24 | 25 | void CPatchAlign::DoIt(DU::CDataPackage* pPackage) 26 | { 27 | //---------------- 28 | if(m_pPatchShifts != 0L) 29 | { delete m_pPatchShifts; 30 | m_pPatchShifts = 0L; 31 | } 32 | CFullAlign::Align(pPackage); 33 | mCorrectFullShift(); 34 | //------------------ 35 | Util_Time aTimer; 36 | aTimer.Measure(); 37 | mCalcPatchShifts(); 38 | float fSeconds = aTimer.GetElapsedSeconds(); 39 | printf("Patch alignment time: %.2f(sec)\n\n", fSeconds); 40 | //--------------------------- 41 | Correct::GCorrectPatchShift::DoIt(m_pPatchShifts, pPackage); 42 | //--------------------------- 43 | CSaveAlign* pSaveAlign = CSaveAlign::GetInstance(); 44 | pSaveAlign->DoLocal(m_pPatchShifts); 45 | } 46 | 47 | void CPatchAlign::mCorrectFullShift(void) 48 | { 49 | nvtxRangePushA("CPatchAlign::mCorrectFullShift"); 50 | CAlignParam* pAlignParam = CAlignParam::GetInstance(); 51 | int iRefFrame = pAlignParam->GetFrameRef(m_pFullShift->m_iNumFrames); 52 | m_pFullShift->MakeRelative(iRefFrame); 53 | //--------------------------- 54 | CInput* pInput = CInput::GetInstance(); 55 | bool bCorrInterp = (pInput->m_iCorrInterp == 0) ? false : true; 56 | bool bMotionDecon = (pInput->m_iInFmMotion == 0) ? false : true; 57 | bool bGenReal = true; 58 | //--------------------------- 59 | Util_Time utilTime; utilTime.Measure(); 60 | Correct::CGenRealStack::DoIt(EBuffer::frm, 61 | bCorrInterp, bMotionDecon, !bGenReal, m_pFullShift); 62 | printf("Global shifts are corrected: %f sec\n", 63 | utilTime.GetElapsedSeconds()); 64 | nvtxRangePop(); 65 | } 66 | 67 | void CPatchAlign::mCalcPatchShifts(void) 68 | { 69 | nvtxRangePushA("CPatchAlign::mCalcPatchShifts"); 70 | CLoadAlign* pLoadAlign = CLoadAlign::GetInstance(); 71 | CAlignParam* pAlignParam = CAlignParam::GetInstance(); 72 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 73 | //---------------------------------------------------- 74 | if(pLoadAlign->IsLoaded()) 75 | { bool bClean = true; 76 | m_pPatchShifts = pLoadAlign->GetPatchShifts(bClean); 77 | m_pPatchShifts->SetFullShift(m_pFullShift); 78 | } 79 | else 80 | { m_pPatchShifts = new CPatchShifts; 81 | int* piStkSize = pBufferPool->m_aiStkSize; 82 | m_pPatchShifts->Setup(pAlignParam->GetNumPatches(), piStkSize); 83 | m_pPatchShifts->SetFullShift(m_pFullShift); 84 | //------------------------------------- 85 | printf("Start to align patches.\n"); 86 | CMeasurePatches meaPatches; 87 | meaPatches.DoIt(m_pPackage, m_pPatchShifts); 88 | } 89 | m_pFullShift = 0L; 90 | //---------------- 91 | nvtxRangePop(); 92 | } 93 | 94 | void CPatchAlign::LogShift(char* pcLogFile) 95 | { 96 | m_pPatchShifts->LogFullShifts(pcLogFile); 97 | m_pPatchShifts->LogPatchShifts(pcLogFile); 98 | m_pPatchShifts->LogFrameShifts(pcLogFile); 99 | } 100 | 101 | -------------------------------------------------------------------------------- /Align/CPeak2D.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include 3 | #include 4 | 5 | using namespace MotionCor2::Align; 6 | 7 | CPeak2D::CPeak2D(void) 8 | { 9 | memset(m_afShift, 0, sizeof(m_afShift)); 10 | } 11 | 12 | CPeak2D::~CPeak2D(void) 13 | { 14 | } 15 | 16 | void CPeak2D::Mask(float* pfImg, int* piImgSize, int* piPos, int iR) 17 | { 18 | int iStartX = piPos[0] - iR; 19 | int iEndX = piPos[0] + iR + 1; 20 | if(iStartX < 0) iStartX = 0; 21 | if(iEndX > piImgSize[0]) iEndX = piImgSize[0]; 22 | //-------------------------------------------- 23 | int iStartY = piPos[1] - iR; 24 | int iEndY = piPos[1] + iR + 1; 25 | if(iStartY < 0) iStartY = 0; 26 | if(iEndY > piImgSize[1]) iEndY = piImgSize[1]; 27 | //-------------------------------------------- 28 | for(int y=iStartY; y iR) continue; 34 | pfImg[i+x] = 0.0f; 35 | } 36 | } 37 | } 38 | 39 | void CPeak2D::DoIt(float* pfImg, int* piImgSize) 40 | { 41 | m_pfImg = pfImg; 42 | m_aiImgSize[0] = piImgSize[0]; 43 | m_aiImgSize[1] = piImgSize[1]; 44 | //---------------------------- 45 | int aiPeak1[] = {0, 0}; 46 | mSearchIntPeak(); 47 | mSearchFloatPeak(); 48 | m_afShift[0] = m_afPeak[0] - m_aiImgSize[0] / 2; 49 | m_afShift[1] = m_afPeak[1] - m_aiImgSize[1] / 2; 50 | } 51 | 52 | void CPeak2D::mSearchIntPeak(void) 53 | { 54 | int iPixels = m_aiImgSize[0] * m_aiImgSize[1]; 55 | m_fPeak = m_pfImg[0]; 56 | int iPeak = 0; 57 | //------------ 58 | for(int i=1; i= m_pfImg[i]) continue; 60 | m_fPeak = m_pfImg[i]; 61 | iPeak = i; 62 | } 63 | //---------------- 64 | m_aiPeak[0] = iPeak % m_aiImgSize[0]; 65 | m_aiPeak[1] = iPeak / m_aiImgSize[0]; 66 | //----------------------------------- 67 | if(m_aiPeak[0] == 0) m_aiPeak[0] = 1; 68 | if(m_aiPeak[1] == 0) m_aiPeak[1] = 1; 69 | //----------------------------------- 70 | int iEndX = m_aiImgSize[0] - 1; 71 | int iEndY = m_aiImgSize[1] - 1; 72 | if(m_aiPeak[0] == iEndX) m_aiPeak[0] -= 1; 73 | if(m_aiPeak[1] == iEndY) m_aiPeak[1] -= 1; 74 | } 75 | 76 | bool CPeak2D::mIsCentralPeak(void) 77 | { 78 | double dX = m_aiPeak[0] - m_aiImgSize[0] * 0.5; 79 | double dY = m_aiPeak[1] - m_aiImgSize[1] * 0.5; 80 | double dR = sqrt(dX * dX + dY * dY); 81 | if(dR <= 3) return true; 82 | else return false; 83 | } 84 | 85 | void CPeak2D::mSearchFloatPeak(void) 86 | { 87 | int ic = m_aiPeak[1] * m_aiImgSize[0] + m_aiPeak[0]; 88 | int xp = ic + 1; 89 | int xm = ic - 1; 90 | int yp = ic + m_aiImgSize[0]; 91 | int ym = ic - m_aiImgSize[0]; 92 | //--------------------------- 93 | double a = (m_pfImg[xp] + m_pfImg[xm]) * 0.5 - m_pfImg[ic]; 94 | double b = (m_pfImg[xp] - m_pfImg[xm]) * 0.5; 95 | double c = (m_pfImg[yp] + m_pfImg[ym]) * 0.5f - m_pfImg[ic]; 96 | double d = (m_pfImg[yp] - m_pfImg[ym]) * 0.5; 97 | double dCentX = -b / (2 * a + 1e-30); 98 | double dCentY = -d / (2 * c + 1e-30); 99 | //----------------------------------- 100 | if(fabs(dCentX) > 1) dCentX = 0; 101 | if(fabs(dCentY) > 1) dCentY = 0; 102 | m_afPeak[0] = (float)(m_aiPeak[0] + dCentX); 103 | m_afPeak[1] = (float)(m_aiPeak[1] + dCentY); 104 | /* 105 | m_fPeak = (float)(a * dCentX * dCentX + b * dCentX 106 | + c * dCentY * dCentY + d * dCentY 107 | + m_pfImg[ic]); 108 | */ 109 | } 110 | -------------------------------------------------------------------------------- /Align/CZbinStack.cpp: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include "../DataUtil/CDataUtilInc.h" 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace MotionCor2; 13 | using namespace MotionCor2::Align; 14 | namespace DU = MotionCor2::DataUtil; 15 | 16 | CZbinStack::CZbinStack(void) 17 | { 18 | } 19 | 20 | CZbinStack::~CZbinStack(void) 21 | { 22 | } 23 | 24 | //----------------------------------------------------------------- 25 | // Need to revisit !!! 26 | //----------------------------------------------------------------- 27 | void CZbinStack::DoIt(DU::CDataPackage* pPackage) 28 | { 29 | DU::CMrcStack* pAlnStack = pPackage->m_pAlnStack; 30 | if(pAlnStack == 0L) return; 31 | //------------------------- 32 | CInput* pInput = CInput::GetInstance(); 33 | if(pInput->m_aiOutStack[0] <= 0) return; 34 | if(pInput->m_aiOutStack[1] <= 1) return; 35 | //-------------------------------------- 36 | m_pMrcStack = pAlnStack; 37 | DU::CFmGroupParam aFmGroupParam; 38 | aFmGroupParam.Setup(pInput->m_aiOutStack[1], pPackage->m_pFmIntParam); 39 | //-------------------------------------------------------------------- 40 | int iNumGroups = aFmGroupParam.m_iNumGroups; 41 | for(int i=0; im_aiStkSize[2]; i++) 50 | { pAlnStack->DeleteFrame(i); 51 | } 52 | pAlnStack->m_aiStkSize[2] = iNumGroups; 53 | m_pMrcStack = 0L; 54 | } 55 | 56 | void CZbinStack::mGroup(int iGroup, int iGroupStart, int iGroupSize) 57 | { 58 | float* pfBinnedFm = (float*)m_pMrcStack->GetFrame(iGroup); 59 | float* pfFm = (float*)m_pMrcStack->GetFrame(iGroupStart); 60 | if(iGroup != iGroupStart) 61 | { memcpy(pfBinnedFm, pfFm, m_pMrcStack->m_tFmBytes); 62 | } 63 | int iPixels = m_pMrcStack->GetPixels(); 64 | for(int i=1; iGetFrame(i+iGroupStart); 66 | for(int j=0; j 3 | #include 4 | 5 | using namespace MotionCor2::Align; 6 | 7 | static __global__ void mGNormByStd2D 8 | ( float* gfImg, 9 | int iSizeX, 10 | int iPadX, 11 | int iWinX, 12 | int iWinY 13 | ) 14 | { int ix = blockIdx.x * blockDim.x + threadIdx.x; 15 | if(ix >= iSizeX) return; 16 | //---------------------- 17 | int iOffsetX = ix - iWinX / 2; 18 | int iOffsetY = blockIdx.y - iWinY / 2; 19 | //------------------------------------------------ 20 | float fMean = 0.0f, fStd = 0.0f, fVal = 0.0f; 21 | int iCount = 0; 22 | for(int j=0; j= gridDim.y) continue; 26 | for(int i=0; i= iSizeX) continue; 30 | fVal = gfImg[y * iPadX + x]; 31 | fMean += fVal; 32 | fStd += (fVal * fVal); 33 | iCount += 1; 34 | } 35 | } 36 | fMean /= iCount; 37 | fStd = fStd / iCount - fMean * fMean; 38 | //----------------------------------- 39 | ix = blockIdx.y * iPadX + blockIdx.x * blockDim.x + threadIdx.x; 40 | if(fStd < 0) gfImg[ix] = 0.0f; 41 | else gfImg[ix] /= (fStd + (float)1e-20); 42 | } 43 | 44 | GNormByStd2D::GNormByStd2D(void) 45 | { 46 | } 47 | 48 | GNormByStd2D::~GNormByStd2D(void) 49 | { 50 | } 51 | 52 | void GNormByStd2D::DoIt(float* gfImg, int* piImgSize, bool bPadded, 53 | int* piWinSize, cudaStream_t stream) 54 | { 55 | if(gfImg == 0L) return; 56 | //--------------------- 57 | int iImageX = bPadded ? (piImgSize[0] / 2 - 1) * 2 : piImgSize[0]; 58 | dim3 aBlockDim(512, 1); 59 | dim3 aGridDim( (iImageX + aBlockDim.x - 1)/ aBlockDim.x, 60 | piImgSize[1] ); 61 | mGNormByStd2D<<>>(gfImg, iImageX, 62 | piImgSize[0], piWinSize[0], piWinSize[1]); 63 | } 64 | -------------------------------------------------------------------------------- /Align/GNormByStd2D_bak.cu: -------------------------------------------------------------------------------- 1 | #include "CAlignInc.h" 2 | #include 3 | #include 4 | 5 | using namespace DfCorr::Align; 6 | 7 | static __global__ void mGNormByStd2D 8 | ( float* gfImg, 9 | int iSizeX, 10 | int iPadX, 11 | int iWinX, 12 | int iWinY 13 | ) 14 | { int x = blockIdx.x * blockDim.x + threadIdx.x; 15 | if(x >= iSizeX) return; 16 | //--------------------- 17 | int iStartX = x - iWinX / 2; 18 | if(iStartX < 0) iStartX = 0; 19 | else if((iStartX + iWinX) > iSizeX) iStartX = iSizeX - iWinX; 20 | int iStartY = (int)blockIdx.y - iWinY / 2; 21 | if(iStartY < 0) iStartY = 0; 22 | else if((iStartY + iWinY) > gridDim.y) iStartY = gridDim.y - iWinY; 23 | //----------------------------------------------------------------- 24 | float* gfBlock = gfImg + iStartY * iPadX + iStartX; 25 | float fMean = 0.0f, fStd = 0.0f, fVal = 0.0f; 26 | float fFact = 1.0f / (iWinX * iWinX); 27 | for(int y=0; y>>(gfImg, iImageX, 59 | piImgSize[0], piWinSize[0], piWinSize[1]); 60 | } 61 | -------------------------------------------------------------------------------- /BadPixel/CCorrectMain.cpp: -------------------------------------------------------------------------------- 1 | #include "CCorrectMain.h" 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace MotionCor2; 12 | using namespace MotionCor2::BadPixel; 13 | 14 | CCorrectMain::CCorrectMain(void) 15 | { 16 | } 17 | 18 | CCorrectMain::~CCorrectMain(void) 19 | { 20 | } 21 | 22 | void CCorrectMain::DoIt(int iDefectSize) 23 | { 24 | nvtxRangePushA("CCorrectMain::DoIt"); 25 | m_iDefectSize = iDefectSize; 26 | //-------------------------- 27 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 28 | CStackBuffer* pFrmBuffer = pBufferPool->GetBuffer(EBuffer::frm); 29 | m_aiPadSize[0] = pFrmBuffer->m_aiCmpSize[0] * 2; 30 | m_aiPadSize[1] = pFrmBuffer->m_aiCmpSize[1]; 31 | //------------------------------------------ 32 | mSetGpus(pFrmBuffer->m_piGpuIDs, pFrmBuffer->m_iNumGpus); 33 | mCreateStreams(2); 34 | //---------------- 35 | for(int i=0; im_iNumGpus; i++) 36 | { mCorrectFrames(i); 37 | } 38 | mDeleteStreams(); 39 | nvtxRangePop(); 40 | } 41 | 42 | void CCorrectMain::mCorrectFrames(int iNthGpu) 43 | { 44 | CBufferPool* pBufferPool = CBufferPool::GetInstance(); 45 | CStackBuffer* pFrmBuffer = pBufferPool->GetBuffer(EBuffer::frm); 46 | CStackBuffer* pTmpBuffer = pBufferPool->GetBuffer(EBuffer::tmp); 47 | //-------------------------------------------------------------- 48 | m_iCurGpu = iNthGpu; 49 | pBufferPool->SetDevice(m_iCurGpu); 50 | //-------------------------------- 51 | void* pvBuf = pBufferPool->GetPinnedBuf(0); 52 | size_t tBytes = m_aiPadSize[0] * m_aiPadSize[1] * sizeof(char); 53 | cufftComplex* gCmpBuf = pTmpBuffer->GetFrame(m_iCurGpu, 0); 54 | cudaMemcpy(gCmpBuf, pvBuf, tBytes, cudaMemcpyDefault); 55 | //---------------------------------------------------- 56 | int iNumFrames = pFrmBuffer->GetNumFrames(m_iCurGpu); 57 | for(int i=0; iGetBuffer(EBuffer::frm); 69 | CStackBuffer* pTmpBuffer = pBufferPool->GetBuffer(EBuffer::tmp); 70 | //-------------------------------------------------------------- 71 | cufftComplex* gCmpFrm = pFrmBuffer->GetFrame(m_iCurGpu, iFrame); 72 | cufftComplex* gCmpMap = pTmpBuffer->GetFrame(m_iCurGpu, 0); 73 | //--------------------------------------------------------- 74 | float* gfPadFrm = reinterpret_cast(gCmpFrm); 75 | unsigned char* gucMap = reinterpret_cast(gCmpMap); 76 | //---------------------------------------------------------------- 77 | GCorrectBad aGCorrectBad; 78 | aGCorrectBad.SetWinSize(m_iDefectSize); 79 | aGCorrectBad.GDoIt(gfPadFrm, gucMap, m_aiPadSize, true, stream); 80 | } 81 | 82 | -------------------------------------------------------------------------------- /BadPixel/CCorrectMain.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include "../MrcUtil/CMrcUtilInc.h" 5 | #include 6 | 7 | namespace MotionCor2 8 | { 9 | namespace BadPixel 10 | { 11 | 12 | class GCorrectBad 13 | { 14 | public: 15 | GCorrectBad(void); 16 | ~GCorrectBad(void); 17 | void SetWinSize(int iSize); 18 | void GDoIt 19 | ( float* gfFrame, 20 | unsigned char* gucBadMap, 21 | int* piFrmSize, 22 | bool bPadded, 23 | cudaStream_t stream=0 24 | ); 25 | private: 26 | int m_iWinSize; 27 | }; //GCorrectBad 28 | 29 | class CCorrectMain : public Util::CMultiGpuBase 30 | { 31 | public: 32 | CCorrectMain(void); 33 | ~CCorrectMain(void); 34 | void DoIt(int iDefectSize); 35 | private: 36 | void mCorrectFrames(int iNthGpu); 37 | void mCorrectFrame(int iFrame); 38 | int m_aiPadSize[2]; 39 | int m_iDefectSize; 40 | int m_iCurGpu; 41 | }; 42 | 43 | }} 44 | -------------------------------------------------------------------------------- /BadPixel/CTemplate.cpp: -------------------------------------------------------------------------------- 1 | #include "CDetectMain.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | using namespace MotionCor2::BadPixel; 11 | 12 | CTemplate::CTemplate(void) 13 | { 14 | } 15 | 16 | CTemplate::~CTemplate(void) 17 | { 18 | } 19 | 20 | void CTemplate::Create(int* piSize, float* pfMod) 21 | { 22 | m_aiSize[0] = piSize[0]; 23 | m_aiSize[1] = piSize[1]; 24 | int iSize = m_aiSize[0] * m_aiSize[1]; 25 | //------------------------------------ 26 | int iEndX = m_aiSize[0] - 1; 27 | int iEndY = m_aiSize[1] - 1; 28 | //-------------------------- 29 | for(int i=0; i 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::BadPixel; 9 | 10 | static __global__ void mGCombine 11 | ( unsigned char* gucMap1, 12 | unsigned char* gucMap2, 13 | int iSizeX, 14 | unsigned char* gucRes 15 | ) 16 | { int x = blockIdx.x * blockDim.x + threadIdx.x; 17 | if(x >= iSizeX) return; 18 | //--------------------- 19 | int i = blockIdx.y * iSizeX + x; 20 | gucRes[i] = gucMap1[i] | gucMap2[i]; 21 | } 22 | 23 | GCombineMap::GCombineMap(void) 24 | { 25 | } 26 | 27 | GCombineMap::~GCombineMap(void) 28 | { 29 | } 30 | 31 | void GCombineMap::GDoIt 32 | ( unsigned char* gucMap1, 33 | unsigned char* gucMap2, 34 | unsigned char* gucResMap, 35 | int* piMapSize 36 | ) 37 | { dim3 aBlockDim(1024, 1), aGridDim(1, piMapSize[1]); 38 | aGridDim.x = piMapSize[0] / aBlockDim.x; 39 | if((piMapSize[0] % aBlockDim.x) > 0) aGridDim.x += 1; 40 | //--------------------------------------------------- 41 | mGCombine<<>>(gucMap1, gucMap2, 42 | piMapSize[0], gucResMap); 43 | } 44 | 45 | unsigned char* GCombineMap::GCopyMap 46 | ( unsigned char* pucMap, 47 | int* piMapSize 48 | ) 49 | { unsigned char* gucBuf = 0L; 50 | size_t tBytes = piMapSize[0] * piMapSize[1] * sizeof(char); 51 | cudaMalloc(&gucBuf, tBytes); 52 | cudaMemcpy(gucBuf, pucMap, tBytes, cudaMemcpyDefault); 53 | return gucBuf; 54 | } 55 | -------------------------------------------------------------------------------- /BadPixel/GCorrectBad.cu: -------------------------------------------------------------------------------- 1 | #include "CCorrectMain.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::BadPixel; 9 | 10 | //------------------------------------------------------------------- 11 | // 1. gfFrame could be padded. In this case, iPadX = (iSizeX/2+1)*2. 12 | // Otherwise iPadX = iFrameX. 13 | // 2. gucBad is also padded if gfFrame is padded. 14 | //------------------------------------------------------------------- 15 | static __device__ bool mGFindGood 16 | ( int iFrameX, 17 | int iPadX, 18 | int iWinSize, 19 | unsigned int next, 20 | unsigned char* gucBad, 21 | float* gfFrame 22 | ) 23 | { int iX = 0, iY = 0; 24 | int iWinSize2 = iWinSize * iWinSize; 25 | int iHalfWin = iWinSize / 2; 26 | int x = blockIdx.x * blockDim.x + threadIdx.x; 27 | for(int k=0; k<500; k++) 28 | { next *= 997; 29 | iX = next % iWinSize2; 30 | iY = iX / iWinSize - iHalfWin + blockIdx.y; 31 | if(iY < 0 || iY >= gridDim.y) continue; 32 | //------------------------------------- 33 | iX = iX % iWinSize - iHalfWin + x; 34 | if(iX < 0 || iX >= iFrameX) continue; 35 | //----------------------------------- 36 | iX += (iY * iPadX); 37 | if(gucBad[iX] == 1) continue; 38 | gfFrame[blockIdx.y * iPadX + x] = gfFrame[iX]; 39 | return true; 40 | } 41 | return false; 42 | } 43 | 44 | static __global__ void mGCorrect 45 | ( float* gfFrame, 46 | int iFrameX, 47 | int iPadX, 48 | unsigned char* gucBad, 49 | int iWinSize 50 | ) 51 | { int x = blockIdx.x * blockDim.x + threadIdx.x; 52 | if(x >= iFrameX) return; 53 | int i = blockIdx.y * iPadX + x; 54 | if(gucBad[i] == 0) return; 55 | //------------------------ 56 | unsigned int next = i * 109 + 619; 57 | for(int j=0; j<10; j++) 58 | { bool bFind = mGFindGood(iFrameX, iPadX, iWinSize, 59 | next, gucBad, gfFrame); 60 | if(bFind) return; 61 | iWinSize += 50; 62 | next *= 997; 63 | } 64 | //-------------------------------- 65 | int iX = next % (iFrameX * gridDim.y); 66 | int iY = iX / iFrameX; 67 | iX = iX % iFrameX; 68 | gfFrame[i] = gfFrame[iY * iPadX + iX]; 69 | } 70 | 71 | GCorrectBad::GCorrectBad(void) 72 | { 73 | m_iWinSize = 31; 74 | } 75 | 76 | GCorrectBad::~GCorrectBad(void) 77 | { 78 | } 79 | 80 | void GCorrectBad::SetWinSize(int iSize) 81 | { 82 | if(iSize <= m_iWinSize) return; 83 | m_iWinSize = iSize; 84 | } 85 | 86 | void GCorrectBad::GDoIt 87 | ( float* gfFrame, 88 | unsigned char* gucBadMap, 89 | int* piFrmSize, 90 | bool bPadded, 91 | cudaStream_t stream 92 | ) 93 | { int iFrameX = piFrmSize[0]; 94 | int iPadX = iFrameX; 95 | if(bPadded) iFrameX = (iPadX / 2 - 1) * 2; 96 | //---------------------------------------- 97 | dim3 aBlockDim(512, 1); 98 | dim3 aGridDim(1, piFrmSize[1]); 99 | aGridDim.x = iFrameX / aBlockDim.x; 100 | if((iFrameX % aBlockDim.x) > 0) aGridDim.x += 1; 101 | //---------------------------------------------- 102 | mGCorrect<<>>(gfFrame, iFrameX, iPadX, 103 | gucBadMap, m_iWinSize); 104 | } 105 | 106 | -------------------------------------------------------------------------------- /BadPixel/GDetectHot.cu: -------------------------------------------------------------------------------- 1 | #include "CDetectMain.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::BadPixel; 9 | 10 | static __global__ void mGDetectHot 11 | ( float* gfImg, 12 | int iPadX, 13 | int iSizeY, 14 | float fTol, 15 | unsigned char* gucBadMap 16 | ) 17 | { int y = blockIdx.y * blockDim.y + threadIdx.y; 18 | if(y >= iSizeY) return; 19 | int i = y * iPadX + blockIdx.x; 20 | if(gfImg[i] <= fTol) gucBadMap[i] = 0; 21 | else gucBadMap[i] = 1; 22 | } 23 | 24 | GDetectHot::GDetectHot(void) 25 | { 26 | m_iNumHots = 0; 27 | } 28 | 29 | GDetectHot::~GDetectHot(void) 30 | { 31 | } 32 | 33 | void GDetectHot::DoIt 34 | ( float* gfPadImg, 35 | float* gfPadBuf, 36 | int* piPadSize, 37 | float fStdThreshold, 38 | unsigned char* pucBadMap 39 | ) 40 | { Util::GCalcMoment2D calcMoment; 41 | calcMoment.SetSize(piPadSize, true); 42 | float fMean = calcMoment.DoIt(gfPadImg, 1, true); 43 | float fStd = calcMoment.DoIt(gfPadImg, 2, true); 44 | fStd = fStd - fMean * fMean; 45 | fStd = (float)sqrtf(fmaxf(fStd, 0)); 46 | //---------------------------------- 47 | float fDelta = fStdThreshold * fStd; 48 | if(fDelta < 10) fDelta = 10; 49 | float fMax = fMean + fDelta; 50 | //-------------------------- 51 | int iSizeX = (piPadSize[0] / 2 - 1) * 2; 52 | dim3 aBlockDim(1, 64); 53 | dim3 aGridDim(iSizeX, 1); 54 | aGridDim.y = (piPadSize[1] + aBlockDim.y - 1) / aBlockDim.y; 55 | mGDetectHot<<>> 56 | ( gfPadImg, piPadSize[0], piPadSize[1], 57 | fMax, pucBadMap ); 58 | //------------------ 59 | printf("Mean & Std: %8.2f %8.2f\n", fMean, fStd); 60 | printf("Hot pixel threshold: %8.2f\n\n", fMax); 61 | } 62 | -------------------------------------------------------------------------------- /BadPixel/GDetectPatch.cu: -------------------------------------------------------------------------------- 1 | #include "CDetectMain.h" 2 | #include "../CMainInc.h" 3 | #include "../MrcUtil/CMrcUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::BadPixel; 9 | 10 | static __global__ void mGThreshold 11 | ( float* gfPadCC, 12 | int iSizeX, 13 | int iPadX, 14 | float fThreshold 15 | ) 16 | { int x = blockIdx.x * blockDim.x + threadIdx.x; 17 | if(x >= iSizeX) return; 18 | //--------------------- 19 | int i = blockIdx.y * iPadX + x; 20 | if(gfPadCC[i] <= fThreshold) gfPadCC[i] = 0; 21 | else gfPadCC[i] = 1; 22 | } 23 | 24 | static __global__ void mGUpdateBadMap 25 | ( float* gfPadCC, 26 | unsigned char* gucBadMap, 27 | int iSizeX, 28 | int iPadX, 29 | int iModSizeX, 30 | int iModSizeY 31 | ) 32 | { int x = blockIdx.x * blockDim.x + threadIdx.x; 33 | if((x + iModSizeX) >= iSizeX) return; 34 | if((blockIdx.y + iModSizeY) >= gridDim.y) return; 35 | //----------------------------------------------- 36 | int i = blockIdx.y * iPadX + x; 37 | if(gfPadCC[i] == 0) return; 38 | //------------------------- 39 | int iOffset = blockIdx.y * iPadX + x; 40 | for(int y=0; ySetDevice(0); 70 | //----------------- 71 | Util::GCalcMoment2D calcMoment; 72 | calcMoment.SetSize(piPadSize, true); 73 | float fMean = calcMoment.DoIt(gfPadCC, 1, true); 74 | float fStd = calcMoment.DoIt(gfPadCC, 2, true); 75 | fStd = (float)sqrtf(fmaxf(0, fStd - fMean * fMean)); 76 | //----------------- 77 | m_fCCThreshold = fMean + fStdThreshold * fStd; 78 | printf("CC Mean Std Threshold: %.3e %.3e %.3f\n\n", 79 | fMean, fStd, m_fCCThreshold); 80 | //----------------- 81 | mUpdateBadMap(gfPadCC, pucBadMap, piPadSize, piModSize); 82 | } 83 | 84 | void GDetectPatch::mUpdateBadMap 85 | ( float* gfPadCC, 86 | unsigned char* pucBadMap, 87 | int* piPadSize, 88 | int* piModSize 89 | ) 90 | { int iImgSizeX = (piPadSize[0] / 2 - 1) * 2; 91 | dim3 aBlockDim(512, 1); 92 | dim3 aGridDim(1, piPadSize[1]); 93 | aGridDim.x = (iImgSizeX + aBlockDim.x - 1) / aBlockDim.x; 94 | //------------------------------------------------------- 95 | // convert gfCCMap to binary map by thresholding. 96 | //------------------------------------------------------- 97 | mGThreshold<<>>(gfPadCC, iImgSizeX, 98 | piPadSize[0], m_fCCThreshold); 99 | //------------------------------------ 100 | // update the existing bad pixel map 101 | //------------------------------------ 102 | mGUpdateBadMap<<>>(gfPadCC, pucBadMap, 103 | iImgSizeX, piPadSize[0], piModSize[0], piModSize[1]); 104 | } 105 | 106 | -------------------------------------------------------------------------------- /BadPixel/GLabelPatch.cu: -------------------------------------------------------------------------------- 1 | #include "CDetectMain.h" 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace MotionCor2::BadPixel; 7 | 8 | static __global__ void mGLabelPatch 9 | ( float* gfImg, 10 | int iSizeX, 11 | int iSizeY, 12 | int* giPatchList, 13 | int iNumPatches, 14 | int iRadius) 15 | { 16 | int iPatch = blockIdx.x * blockDim.x + threadIdx.x; 17 | if(iPatch >= iNumPatches) return; 18 | //------------------------------- 19 | iPatch = giPatchList[iPatch]; 20 | int iCentX = iPatch % iSizeX; 21 | int iCentY = iPatch / iSizeX; 22 | //--------------------------- 23 | float fMax = 0.0f; 24 | for(int y=-iRadius; y<=iRadius; y++) 25 | { int yy = y + iCentY; 26 | if(yy < 0 || yy >= iSizeY) continue; 27 | for(int x=-iRadius; x<=iRadius; x++) 28 | { int xx = x + iCentX; 29 | if(xx < 0 || xx >= iSizeX) continue; 30 | float fVal = gfImg[yy * iSizeX + xx]; 31 | if(fVal > fMax) fVal = fMax; 32 | } 33 | } 34 | fMax = fMax * 1.25f + 10.0f; 35 | //-------------------------- 36 | for(int i=0; i<10; i++) 37 | { int x = (int)(iRadius * cosf(i * 0.314159f)) + iCentX; 38 | int y = (int)(iRadius * sinf(i * 0.314159f)) + iCentY; 39 | if(x >= 0 && y >= 0 && x < iSizeX && y < iSizeY) 40 | { gfImg[y * iSizeX + x] = fMax; 41 | } 42 | x = iCentX * 2 - x; 43 | y = iCentX * 2 - y; 44 | if(x >= 0 && y >= 0 && x < iSizeX && y < iSizeY) 45 | { gfImg[y * iSizeX + x] = fMax; 46 | } 47 | } 48 | } 49 | 50 | GLabelPatch::GLabelPatch(void) 51 | { 52 | m_iRadius = 8; 53 | } 54 | 55 | GLabelPatch::~GLabelPatch(void) 56 | { 57 | } 58 | 59 | void GLabelPatch::SetLabelSize(int iRadius) 60 | { 61 | m_iRadius = iRadius; 62 | } 63 | 64 | void GLabelPatch::DoIt 65 | ( float* gfImg, 66 | int* piImgSize, 67 | int* piPatchList, 68 | int iNumPatches) 69 | { 70 | if(iNumPatches == 0) return; 71 | //-------------------------- 72 | int* giPatchList = 0L; 73 | cudaMalloc(&giPatchList, sizeof(int) * iNumPatches); 74 | cudaMemcpy(giPatchList, piPatchList, sizeof(int) * iNumPatches, 75 | cudaMemcpyDefault); 76 | //-------------------- 77 | dim3 aBlockDim(512, 1); 78 | dim3 aGridDim(iNumPatches / aBlockDim.x + 1, 1); 79 | mGLabelPatch<<>>(gfImg, piImgSize[0], 80 | piImgSize[1], giPatchList, iNumPatches, m_iRadius); 81 | //---------------------------------------------------- 82 | cudaFree(giPatchList); 83 | } 84 | 85 | -------------------------------------------------------------------------------- /BadPixel/GLocalCC.cu: -------------------------------------------------------------------------------- 1 | #include "CDetectMain.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::BadPixel; 8 | 9 | static __constant__ int giRefSize[2]; 10 | static __constant__ int giPadSize[2]; 11 | 12 | //------------------------------------------------------------------- 13 | // 1. The location of each detected patch is represented by the 14 | // coordinate of its first pixel. 15 | // 2. Each patch is defined as a square patch. 16 | // 3. gfCC is the cross correlation map that has the same dimension 17 | // as gfImg. The coordinate of CC peak in the CC map corresponds 18 | // to the patch location in the image. 19 | //------------------------------------------------------------------- 20 | static __global__ void mGLocalCC 21 | ( float* gfPadImg, 22 | int iOffset, 23 | int iPartSize, 24 | float* gfRef, 25 | float* gfPadCC 26 | ) 27 | { int iPix = blockIdx.x * blockDim.x + threadIdx.x; 28 | if(iPix >= iPartSize) return; 29 | //------------------------ 30 | iPix = iPix + iOffset; 31 | int x = iPix % giPadSize[0]; 32 | int y = iPix / giPadSize[0]; 33 | iPix = y * giPadSize[0] + x; 34 | gfPadCC[iPix] = 0.0f; 35 | //------------------- 36 | if((x + giRefSize[0]) >= ((giPadSize[0] / 2 - 1) * 2)) return; 37 | if((y + giRefSize[1]) >= giPadSize[1]) return; 38 | //-------------------------------------------- 39 | float* gfSrc = gfPadImg + iPix; 40 | float fMean = 0.0f, fStd = 0.0f, fCC = 0.0f; 41 | //------------------------------------------ 42 | for(int j=0; j>> 94 | ( gfPadImg, iOffset, iPartSize, m_gfRef, gfPadCC ); 95 | } 96 | -------------------------------------------------------------------------------- /DataUtil/CAlnSums.cpp: -------------------------------------------------------------------------------- 1 | #include "CDataUtilInc.h" 2 | #include "../CMainInc.h" 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::DataUtil; 8 | 9 | 10 | CAlnSums::CAlnSums(void) 11 | { 12 | } 13 | 14 | CAlnSums::~CAlnSums(void) 15 | { 16 | } 17 | 18 | void CAlnSums::Setup(bool bDoseWeight, bool bDoseSelected) 19 | { 20 | int iSum = 0; 21 | strcpy(m_acExts[iSum], ""); 22 | //----------------- 23 | CInput* pInput = CInput::GetInstance(); 24 | if(pInput->m_iAlign == 0) 25 | { if(pInput->m_iSplitSum == 0) return; 26 | strcpy(m_acExts[1], "_ODD"); 27 | strcpy(m_acExts[2], "_EVN"); 28 | return; 29 | } 30 | //----------------- 31 | iSum += 1; 32 | if(bDoseWeight) 33 | { strcpy(m_acExts[iSum], "_DW"); 34 | iSum += 1; 35 | if(bDoseSelected) 36 | { strcpy(m_acExts[iSum], "_DWS"); 37 | iSum += 1; 38 | } 39 | } 40 | //------------------------ 41 | strcpy(m_acExts[iSum], "_ODD"); 42 | strcpy(m_acExts[iSum+1], "_EVN"); 43 | } 44 | 45 | void CAlnSums::GetFileExt(int iIndex, char* pcExt) 46 | { 47 | strcpy(pcExt, m_acExts[iIndex]); 48 | } 49 | -------------------------------------------------------------------------------- /DataUtil/CMrcStack.cpp: -------------------------------------------------------------------------------- 1 | #include "CDataUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::DataUtil; 9 | 10 | CMrcStack::CMrcStack(void) 11 | { 12 | memset(m_aiStkSize, 0, sizeof(m_aiStkSize)); 13 | m_ppvFrames = 0L; 14 | m_iMode = -1; 15 | m_tFmBytes = 0; 16 | m_iBufSize = 0; 17 | //------------------------------------------ 18 | m_iAcqIndex = 0; 19 | m_iStack = 0; 20 | m_fPixSize = 1.0f; 21 | memset(m_afExt, 0, sizeof(m_afExt)); 22 | m_iNumFloats = sizeof(m_afExt) / sizeof(float); 23 | } 24 | 25 | CMrcStack::~CMrcStack(void) 26 | { 27 | this->DeleteFrames(); 28 | } 29 | 30 | void CMrcStack::Create(int iMode, int* piStkSize) 31 | { 32 | //---------------------------------------------------------------- 33 | // reallocate only when the frame byte is changed. 34 | //---------------------------------------------------------------- 35 | size_t tFmBytes = Mrc::C4BitImage::GetImgBytes(iMode, piStkSize); 36 | if(tFmBytes == m_tFmBytes && m_aiStkSize[2] >= piStkSize[2]) 37 | { m_iBufSize = m_aiStkSize[2]; 38 | memcpy(m_aiStkSize, piStkSize, sizeof(m_aiStkSize)); 39 | m_iMode = iMode; 40 | return; 41 | } 42 | //---------------------------------------------------------- 43 | this->DeleteFrames(); 44 | m_iMode = iMode; 45 | m_iBufSize = piStkSize[2]; 46 | memcpy(m_aiStkSize, piStkSize, sizeof(int) * 3); 47 | m_tFmBytes = Mrc::C4BitImage::GetImgBytes(m_iMode, m_aiStkSize); 48 | //-------------------------------------------------------------- 49 | m_ppvFrames = new void*[m_iBufSize]; 50 | for(int i=0; iCreate(iMode, aiStkSize); 61 | } 62 | 63 | void CMrcStack::DeleteFrame(int iFrame) 64 | { 65 | if(m_ppvFrames == 0L) return; 66 | if(m_ppvFrames[iFrame] == 0L) return; 67 | //cudaFreeHost(m_ppvFrames[iFrame]); 68 | delete[] (char*)m_ppvFrames[iFrame]; 69 | m_ppvFrames[iFrame] = 0L; 70 | } 71 | 72 | void CMrcStack::DeleteFrames(void) 73 | { 74 | if(m_ppvFrames == 0L) return; 75 | for(int i=0; i= m_aiStkSize[2]) return 0L; 89 | //------------------------------------------ 90 | size_t tBytes = m_tFmBytes * iFrame; 91 | char* pcFrame = reinterpret_cast(m_ppvFrames[iFrame]); 92 | return pcFrame; 93 | } 94 | 95 | int CMrcStack::GetPixels(void) 96 | { 97 | int iPixels = m_aiStkSize[0] * m_aiStkSize[1]; 98 | return iPixels; 99 | } 100 | 101 | size_t CMrcStack::GetVoxels(void) 102 | { 103 | size_t tVoxels = m_aiStkSize[0] * m_aiStkSize[1]; 104 | tVoxels *= m_aiStkSize[2]; 105 | return tVoxels; 106 | } 107 | 108 | float CMrcStack::GetTiltA(void) 109 | { 110 | return m_afExt[0]; 111 | } 112 | 113 | float CMrcStack::GetPixelSize(void) 114 | { 115 | return m_afExt[11]; 116 | } 117 | 118 | void CMrcStack::GetTomoShift(float* pfShift) 119 | { 120 | if(pfShift == 0L) return; 121 | if(m_iNumFloats < 7) return; 122 | pfShift[0] = m_afExt[5]; 123 | pfShift[1] = m_afExt[6]; 124 | } 125 | -------------------------------------------------------------------------------- /EerUtil/CLoadEerFrames.cpp: -------------------------------------------------------------------------------- 1 | #include "CEerUtilInc.h" 2 | #include "../CMainInc.h" 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | using namespace MotionCor2::EerUtil; 10 | 11 | CLoadEerFrames::CLoadEerFrames(void) 12 | { 13 | m_pucFrames = 0L; 14 | m_piFrmStarts = 0L; 15 | m_piFrmSizes = 0L; 16 | } 17 | 18 | CLoadEerFrames::~CLoadEerFrames(void) 19 | { 20 | this->Clean(); 21 | } 22 | 23 | void CLoadEerFrames::Clean(void) 24 | { 25 | if(m_pucFrames != 0L) delete[] m_pucFrames; 26 | m_pucFrames = 0L; 27 | if(m_piFrmStarts != 0L) delete[] m_piFrmStarts; 28 | m_piFrmStarts = 0L; 29 | if(m_piFrmSizes != 0L) delete[] m_piFrmSizes; 30 | m_piFrmSizes = 0L; 31 | } 32 | 33 | bool CLoadEerFrames::DoIt 34 | ( int iFile, 35 | TIFF* pTiff, 36 | CLoadEerHeader* pLoadHeader 37 | ) 38 | { this->Clean(); 39 | m_pTiff = pTiff; 40 | m_iNumFrames = pLoadHeader->m_iNumFrames; 41 | //--------------------------------------- 42 | struct stat buf; 43 | fstat(iFile, &buf); 44 | unsigned int uiSize = buf.st_size; 45 | m_pucFrames = new unsigned char[uiSize]; 46 | memset(m_pucFrames, 0, sizeof(char) * uiSize); 47 | //-------------------------------------------- 48 | int iBytes = sizeof(int) * m_iNumFrames; 49 | m_piFrmStarts = new int[m_iNumFrames]; 50 | m_piFrmSizes = new int[m_iNumFrames]; 51 | memset(m_piFrmStarts, 0, iBytes); 52 | memset(m_piFrmSizes, 0, iBytes); 53 | //------------------------------ 54 | m_iBytesRead = 0; 55 | CInput* pInput = CInput::GetInstance(); 56 | if(pInput->m_iTiffOrder >= 0) 57 | { for(int i=0; i=0; i--) mReadFrame(i); 62 | } 63 | m_pTiff = 0L; 64 | return true; 65 | } 66 | 67 | unsigned char* CLoadEerFrames::GetEerFrame(int iFrame) 68 | { 69 | if(m_pucFrames == 0L) return 0L; 70 | return m_pucFrames + m_piFrmStarts[iFrame]; 71 | } 72 | 73 | int CLoadEerFrames::GetEerFrameSize(int iFrame) 74 | { 75 | if(m_piFrmSizes == 0L) return 0; 76 | return m_piFrmSizes[iFrame]; 77 | } 78 | 79 | void CLoadEerFrames::mReadFrame(int iFrame) 80 | { 81 | m_piFrmStarts[iFrame] = m_iBytesRead; 82 | unsigned char* pcEerFrm = m_pucFrames + m_iBytesRead; 83 | //--------------------------------------------------- 84 | TIFFSetDirectory(m_pTiff, iFrame); 85 | int iNumStrips = TIFFNumberOfStrips(m_pTiff); 86 | int iFrmBytes = 0; 87 | //---------------- 88 | for(int i=0; i 3 | #include 4 | 5 | using namespace MotionCor2::EerUtil; 6 | 7 | CLoadEerHeader::CLoadEerHeader(void) 8 | { 9 | m_aiCamSize[0] = 4096; 10 | m_aiCamSize[1] = 4096; 11 | m_iNumFrames = 0; 12 | m_usCompression = 0; 13 | m_iNumBits = -1; 14 | m_iEerSampling = 1; 15 | } 16 | 17 | 18 | CLoadEerHeader::~CLoadEerHeader(void) 19 | { 20 | } 21 | 22 | bool CLoadEerHeader::DoIt(TIFF* pTiff, int iEerSampling) 23 | { 24 | m_iEerSampling = iEerSampling; 25 | memset(m_aiCamSize, 0, sizeof(m_aiCamSize)); 26 | memset(m_aiFrmSize, 0, sizeof(m_aiFrmSize)); 27 | //------------------------------------------ 28 | TIFFGetField(pTiff, TIFFTAG_IMAGEWIDTH, &m_aiCamSize[0]); 29 | TIFFGetField(pTiff, TIFFTAG_IMAGELENGTH, &m_aiCamSize[1]); 30 | m_iNumFrames = TIFFNumberOfDirectories(pTiff); 31 | TIFFGetField(pTiff, TIFFTAG_COMPRESSION, &m_usCompression); 32 | if(m_usCompression == 65000) m_iNumBits = 8; 33 | else if(m_usCompression == 65001) m_iNumBits = 7; 34 | else if(m_usCompression == 65002) 35 | { //uint16_t uiRleBits; 36 | //TIFFGetField(pTiff, 65007, &uiRleBits); 37 | //m_iNumBits = uiRleBits; 38 | // need work on this case. 39 | } 40 | else m_iNumBits = -1; 41 | //------------------- 42 | bool bHasError = mCheckError(); 43 | if(bHasError) return false; 44 | //------------------------- 45 | int iFact = 1; 46 | if(m_iEerSampling == 2) iFact = 2; 47 | else if(m_iEerSampling == 3) iFact = 4; 48 | m_aiFrmSize[0] = m_aiCamSize[0] * iFact; 49 | m_aiFrmSize[1] = m_aiCamSize[1] * iFact; 50 | return true; 51 | } 52 | 53 | bool CLoadEerHeader::mCheckError(void) 54 | { 55 | bool bHasError = false; 56 | const char* pcErrSize = "Error: Invalid image size."; 57 | const char* pcErrCmp = "Error: Invalid compression."; 58 | if(m_aiCamSize[0] <= 0 || m_aiCamSize[0] <= 0 || m_iNumFrames <= 0) 59 | { fprintf(stderr, "%s %d %d %d\n", pcErrSize, 60 | m_aiCamSize[0], m_aiCamSize[1], m_iNumFrames); 61 | bHasError = true; 62 | } 63 | if(m_iNumBits <= 0) 64 | { fprintf(stderr, "%s %d\n", pcErrCmp, m_usCompression); 65 | bHasError = true; 66 | } 67 | return bHasError; 68 | } 69 | -------------------------------------------------------------------------------- /EerUtil/CRenderMrcStack.cpp: -------------------------------------------------------------------------------- 1 | #include "CEerUtilInc.h" 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace MotionCor2; 10 | namespace DU = MotionCor2::DataUtil; 11 | using namespace MotionCor2::EerUtil; 12 | 13 | CRenderMrcStack::CRenderMrcStack(void) 14 | { 15 | } 16 | 17 | CRenderMrcStack::~CRenderMrcStack(void) 18 | { 19 | } 20 | 21 | void CRenderMrcStack::DoIt 22 | ( CLoadEerHeader* pLoadEerHeader, 23 | CLoadEerFrames* pLoadEerFrames, 24 | void* pvDataPackage 25 | ) 26 | { m_pLoadEerHeader = pLoadEerHeader; 27 | m_pLoadEerFrames = pLoadEerFrames; 28 | m_aDecodeEerFrame.Setup(m_pLoadEerHeader->m_aiCamSize, 29 | m_pLoadEerHeader->m_iEerSampling); 30 | //----------------------------------- 31 | DU::CDataPackage* pPackage = (DU::CDataPackage*)pvDataPackage; 32 | if(pPackage->m_pFmIntParam->bIntegrate()) 33 | { mRenderInt(pvDataPackage); 34 | } 35 | else mRender(pvDataPackage); 36 | } 37 | 38 | void CRenderMrcStack::mRender(void* pvDataPackage) 39 | { 40 | DU::CDataPackage* pPackage = (DU::CDataPackage*)pvDataPackage; 41 | DU::CMrcStack* pRawStack = pPackage->m_pRawStack; 42 | //----------------------------------------------- 43 | unsigned char* pucMrcFrm = 0L; 44 | for(int i=0; im_aiStkSize[2]; i++) 45 | { pucMrcFrm = (unsigned char*)pRawStack->GetFrame(i); 46 | memset(pucMrcFrm, 0, pRawStack->m_tFmBytes); 47 | int iEerFrm = pPackage->m_pFmIntParam->GetIntFmStart(i); 48 | mDecodeFrame(iEerFrm, pucMrcFrm); 49 | } 50 | } 51 | 52 | void CRenderMrcStack::mRenderInt(void* pvDataPackage) 53 | { 54 | DU::CDataPackage* pPackage = (DU::CDataPackage*)pvDataPackage; 55 | DU::CMrcStack* pRawStack = pPackage->m_pRawStack; 56 | DU::CFmIntParam* pFmIntParam = pPackage->m_pFmIntParam; 57 | //----------------------------------------------------------------- 58 | for(int i=0; im_aiStkSize[2]; i++) 59 | { int iFmSize = pFmIntParam->GetIntFmSize(i); 60 | if(iFmSize == 1) 61 | { void* pvMrcFrm = pRawStack->GetFrame(i); 62 | memset(pvMrcFrm, 0, pRawStack->m_tFmBytes); 63 | int iFmStart = pFmIntParam->GetIntFmStart(i); 64 | mDecodeFrame(iFmStart, (unsigned char*)pvMrcFrm); 65 | } 66 | else mRenderFrame(i, pvDataPackage); 67 | } 68 | } 69 | 70 | void CRenderMrcStack::mRenderFrame(int iIntFrm, void* pvDataPackage) 71 | { 72 | DU::CDataPackage* pPackage = (DU::CDataPackage*)pvDataPackage; 73 | DU::CMrcStack* pRawStack = pPackage->m_pRawStack; 74 | DU::CFmIntParam* pFmIntParam = pPackage->m_pFmIntParam; 75 | //----------------------------------------------------------- 76 | int iIntFmStart = pFmIntParam->GetIntFmStart(iIntFrm); 77 | int iIntFmSize = pFmIntParam->GetIntFmSize(iIntFrm); 78 | //-------------------------------------------------- 79 | unsigned char* pucFrm = (unsigned char*)pRawStack->GetFrame(iIntFrm); 80 | memset(pucFrm, 0, pRawStack->m_tFmBytes); 81 | for(int i=0; iGetEerFrameSize(iEerFrame); 92 | int iEerBits = m_pLoadEerHeader->m_iNumBits; 93 | unsigned char* pEerFrm = m_pLoadEerFrames->GetEerFrame(iEerFrame); 94 | if(iEerBits == 7) 95 | { m_aDecodeEerFrame.Do7Bits(pEerFrm, 96 | iEerFmBytes, pucDecodedFrm); 97 | } 98 | else 99 | { m_aDecodeEerFrame.Do8Bits(pEerFrm, 100 | iEerFmBytes, pucDecodedFrm); 101 | } 102 | } 103 | 104 | -------------------------------------------------------------------------------- /EerUtil/GAddRawFrame.cu: -------------------------------------------------------------------------------- 1 | #include "CEerUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace MotionCor2::EerUtil; 7 | 8 | static __global__ void mGAddRawFrame 9 | ( unsigned char* gucFrm1, 10 | unsigned char* gucFrm2, 11 | unsigned char* gucSum, 12 | unsigned int uiPixels 13 | ) 14 | { unsigned int i = blockIdx.x * blockDim.x + threadIdx.x; 15 | if (i >= uiPixels) return; 16 | gucSum[i] = gucFrm1[i] + gucFrm2[i]; 17 | } 18 | 19 | GAddRawFrame::GAddRawFrame(void) 20 | { 21 | } 22 | 23 | GAddRawFrame::~GAddRawFrame(void) 24 | { 25 | } 26 | 27 | void GAddRawFrame::DoIt 28 | ( unsigned char* gucFrm1, 29 | unsigned char* gucFrm2, 30 | unsigned char* gucSum, 31 | unsigned int uiPixels, 32 | cudaStream_t stream 33 | ) 34 | { dim3 aBlockDim(512, 1, 1); 35 | dim3 aGridDim(1, 1, 1); 36 | aGridDim.x = (uiPixels + aBlockDim.x - 1) / aBlockDim.x; 37 | mGAddRawFrame<<>> 38 | ( gucFrm1, gucFrm2, gucSum, uiPixels 39 | ); 40 | } 41 | 42 | -------------------------------------------------------------------------------- /EerUtil/GDecodeEerFrame.cu: -------------------------------------------------------------------------------- 1 | #include "CEerUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::EerUtil; 8 | 9 | //------------------------------------------------------------------- 10 | // 1. The gain-corrected frame could be padded for FFT. In this 11 | // case iPadX = (iSizeX / 2 + 1) * 2. Otherwise iPadX = iSizeX. 12 | //------------------------------------------------------------------- 13 | static __global__ void mGDecode7Bits 14 | ( unsigned char* gucEerFrame, 15 | unsigned char* gucZeros, 16 | unsigned char* gucSubpixs, 17 | int iNumChunks 18 | ) 19 | { unsigned int i = blockIdx.x * blockDim.x + threadIdx.x; 20 | if(i >= iNumChunks) return; 21 | //------------------------- 22 | unsigned int iV = i * 11; 23 | unsigned int iBitOffset = iV % 8; 24 | iV = *((unsigned int*)(gucEerFrame + (iV >> 3))); 25 | iV = iV >> iBitOffset; 26 | //-------------------- 27 | gucZeros[i] = (unsigned char)(iV & 127); 28 | gucSubpixs[i] = (unsigned char)(((iV >> 7) & 15) ^ 0x0A); 29 | } 30 | 31 | static __global__ void mGDecode8Bits 32 | ( unsigned char* gucEerFrame, 33 | unsigned char* gucZeros, 34 | unsigned char* gucSubpixs, 35 | int iNumChunks 36 | ) 37 | { unsigned int i = blockIdx.x * blockDim.x + threadIdx.x; 38 | if(i >= iNumChunks) return; 39 | //------------------------- 40 | unsigned int iV = i * 12; 41 | unsigned int iBitOffset = iV % 8; 42 | iV = *((unsigned int*)(gucEerFrame + (iV >> 3))); 43 | iV = iV >> iBitOffset; 44 | //-------------------- 45 | gucZeros[i] = (unsigned char)(iV & 255); 46 | gucSubpixs[i] = (unsigned char)(((iV >> 8) & 15) ^ 0x0A); 47 | } 48 | 49 | GDecodeEerFrame::GDecodeEerFrame(void) 50 | { 51 | } 52 | 53 | GDecodeEerFrame::~GDecodeEerFrame(void) 54 | { 55 | } 56 | 57 | void GDecodeEerFrame::DoIt 58 | ( unsigned char* gucEerFrame, 59 | unsigned char* gucZeros, 60 | unsigned char* gucSubpixs, 61 | int iEerFrameBytes, 62 | bool b7Bits, 63 | cudaStream_t stream 64 | ) 65 | { unsigned int iChunkSize = b7Bits ? 11 : 12; 66 | unsigned int iNumChunks = iEerFrameBytes / iChunkSize; 67 | //---------------------------------------------------- 68 | dim3 aBlockDim(512, 1); 69 | dim3 aGridDim(1, 1); 70 | aGridDim.x = (iNumChunks + aBlockDim.x - 1) / aBlockDim.x; 71 | //-------------------------------------------------------- 72 | if(b7Bits) 73 | { mGDecode7Bits<<>> 74 | ( gucEerFrame, gucZeros, gucSubpixs, iNumChunks 75 | ); 76 | } 77 | else 78 | { mGDecode8Bits<<>> 79 | ( gucEerFrame, gucZeros, gucSubpixs, iNumChunks 80 | ); 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /FindCtf/CFindCtf1D.cpp: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include "../Util/CUtilInc.h" 3 | #include "../MrcUtil/CMrcUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace MotionCor2::FindCtf; 12 | 13 | CFindCtf1D::CFindCtf1D(void) 14 | { 15 | m_pFindDefocus1D = 0L; 16 | m_gfRadialAvg = 0L; 17 | } 18 | 19 | CFindCtf1D::~CFindCtf1D(void) 20 | { 21 | this->Clean(); 22 | } 23 | 24 | void CFindCtf1D::Clean(void) 25 | { 26 | if(m_pFindDefocus1D != 0L) 27 | { delete m_pFindDefocus1D; 28 | m_pFindDefocus1D = 0L; 29 | } 30 | if(m_gfRadialAvg != 0L) 31 | { cudaFree(m_gfRadialAvg); 32 | m_gfRadialAvg = 0L; 33 | } 34 | } 35 | 36 | void CFindCtf1D::Setup1(int* piSpectSize) 37 | { 38 | this->Clean(); 39 | CFindCtfBase::Setup1(piSpectSize); 40 | //----------------- 41 | cudaMalloc(&m_gfRadialAvg, sizeof(float) * m_aiSpectSize[0]); 42 | //----------------- 43 | m_pFindDefocus1D = new CFindDefocus1D; 44 | m_pFindDefocus1D->Setup1(m_aiSpectSize[0]); 45 | } 46 | 47 | void CFindCtf1D::Setup2(CCtfParam* pCtfParam) 48 | { 49 | CFindCtfBase::Setup2(pCtfParam); 50 | //----------------- 51 | m_pFindDefocus1D->Setup2(m_pCtfParam0); 52 | m_pFindDefocus1D->SetResRange(m_afResRange); 53 | } 54 | 55 | void CFindCtf1D::DoIt(float* gfSpect) 56 | { 57 | CFindCtfBase::DoIt(gfSpect); 58 | mCalcRadialAverage(); 59 | //----------------- 60 | bool bAngstrom = true, bDegree = true; 61 | float fInitDf = m_pCtfParam0->GetDfMin(bAngstrom); 62 | float fInitPhase = m_pCtfParam0->GetExtPhase(bDegree); 63 | //----------------- 64 | float afDfRange[2] = {0.0f}; 65 | mGetDfRange(fInitDf, m_fDfRange, afDfRange); 66 | float afPhaseRange[2] = {0.0f}; 67 | mGetPhaseRange(fInitPhase, m_fPhaseRange, afPhaseRange); 68 | mFindDefocus(afDfRange, afPhaseRange); 69 | //----------------- 70 | fInitDf = m_pCtfParamN->GetDfMin(bAngstrom); 71 | fInitPhase = m_pCtfParamN->GetExtPhase(bDegree); 72 | mGetDfRange(fInitDf, 0.3f * m_fDfRange, afDfRange); 73 | mGetPhaseRange(fInitPhase, 0.3f * m_fPhaseRange, afPhaseRange); 74 | mFindDefocus(afDfRange, afPhaseRange); 75 | } 76 | 77 | void CFindCtf1D::mFindDefocus(float* pfDfRange, float* pfPhaseRange) 78 | { 79 | m_pFindDefocus1D->DoIt(pfDfRange, pfPhaseRange, m_gfRadialAvg); 80 | //----------------- 81 | bool bDegree = true, bAngstrom = true; 82 | m_pCtfParamN->SetExtPhase(m_pFindDefocus1D->m_fBestPhase, bDegree); 83 | m_pCtfParamN->SetDfs(m_pFindDefocus1D->m_fBestDf, 84 | m_pFindDefocus1D->m_fBestDf, bAngstrom); 85 | m_pCtfParamN->m_fScore = m_pFindDefocus1D->m_fMaxCC; 86 | } 87 | 88 | void CFindCtf1D::mCalcRadialAverage(void) 89 | { 90 | GRadialAvg aGRadialAvg; 91 | aGRadialAvg.DoIt(m_gfSpect, m_gfRadialAvg, m_aiSpectSize); 92 | } 93 | 94 | -------------------------------------------------------------------------------- /FindCtf/CFindCtf2D.cpp: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include "../Util/CUtilInc.h" 3 | #include "../MrcUtil/CMrcUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace MotionCor2::FindCtf; 12 | 13 | CFindCtf2D::CFindCtf2D(void) 14 | { 15 | m_pFindDefocus2D = 0L; 16 | } 17 | 18 | CFindCtf2D::~CFindCtf2D(void) 19 | { 20 | this->Clean(); 21 | } 22 | 23 | void CFindCtf2D::Clean(void) 24 | { 25 | if(m_pFindDefocus2D != 0L) 26 | { delete m_pFindDefocus2D; 27 | m_pFindDefocus2D = 0L; 28 | } 29 | CFindCtf1D::Clean(); 30 | } 31 | 32 | void CFindCtf2D::Setup1(int* piSpectSize) 33 | { 34 | this->Clean(); 35 | CFindCtf1D::Setup1(piSpectSize); 36 | } 37 | 38 | void CFindCtf2D::Setup2(CCtfParam* pCtfParam) 39 | { 40 | CFindCtf1D::Setup2(pCtfParam); 41 | //--------------------------- 42 | m_pFindDefocus2D = new CFindDefocus2D; 43 | m_pFindDefocus2D->Setup1(pCtfParam, m_aiSpectSize); 44 | m_pFindDefocus2D->Setup2(m_afResRange); 45 | } 46 | 47 | void CFindCtf2D::DoIt(float* gfSpect) 48 | { 49 | CFindCtf1D::DoIt(gfSpect); 50 | //------------------------ 51 | bool bAngstrom = true, bDegree = true; 52 | float fDfMean = m_pCtfParamN->GetDfMin(bAngstrom); 53 | float fPhase = m_pCtfParamN->GetExtPhase(bDegree); 54 | //------------------------------------------------ 55 | m_pFindDefocus2D->Setup2(m_afResRange); 56 | m_pFindDefocus2D->Setup3(fDfMean, 0.0f, 0.0f, fPhase); 57 | m_pFindDefocus2D->DoIt(m_gfSpect, m_fPhaseRange); 58 | mGetResults(); 59 | } 60 | 61 | void CFindCtf2D::Refine 62 | ( float afDfMean[2], 63 | float afAstRatio[2], 64 | float afAstAngle[2], 65 | float afExtPhase[2] 66 | ) 67 | { m_pFindDefocus2D->Setup3(afDfMean[0], afAstRatio[0], 68 | afAstAngle[0], afExtPhase[0]); 69 | m_pFindDefocus2D->Refine(m_gfSpect, afDfMean[1], 70 | afAstRatio[1], afAstAngle[1], afExtPhase[1]); 71 | mGetResults(); 72 | } 73 | 74 | void CFindCtf2D::mGetResults(void) 75 | { 76 | bool bAngstrom = true, bDegree = true; 77 | m_pCtfParamN->SetDfMin(m_pFindDefocus2D->GetDfMin(), bAngstrom); 78 | m_pCtfParamN->SetDfMax(m_pFindDefocus2D->GetDfMax(), bAngstrom); 79 | m_pCtfParamN->SetAstAngle(m_pFindDefocus2D->GetAngle(), bDegree); 80 | m_pCtfParamN->SetExtPhase(m_pFindDefocus2D->GetExtPhase(), bDegree); 81 | m_pCtfParamN->m_fScore = m_pFindDefocus2D->GetScore(); 82 | m_pCtfParamN->m_fCtfRes = m_pFindDefocus2D->GetCtfRes(); 83 | } 84 | -------------------------------------------------------------------------------- /FindCtf/CFindCtfBase.cpp: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace MotionCor2::FindCtf; 10 | 11 | CFindCtfBase::CFindCtfBase(void) 12 | { 13 | m_fPhaseRange = 0.0f; 14 | m_pCtfParam0 = new CCtfParam; // initial values 15 | m_pCtfParamN = new CCtfParam; // final values 16 | } 17 | 18 | CFindCtfBase::~CFindCtfBase(void) 19 | { 20 | if(m_pCtfParam0 != 0L) delete m_pCtfParam0; 21 | if(m_pCtfParamN != 0L) delete m_pCtfParamN; 22 | m_pCtfParam0 = 0L; 23 | m_pCtfParamN = 0L; 24 | } 25 | 26 | void CFindCtfBase::Setup1(int* piSpectSize) 27 | { 28 | m_aiSpectSize[0] = piSpectSize[0]; 29 | m_aiSpectSize[1] = piSpectSize[1]; 30 | } 31 | 32 | void CFindCtfBase::Setup2(CCtfParam* pCtfParam) 33 | { 34 | m_pCtfParam0->Setup(pCtfParam); 35 | m_pCtfParamN->Setup(pCtfParam); 36 | //----------------------------------------------- 37 | // 1) m_afResRange decides the range of Fourier 38 | // components are involved in CTF estimation. 39 | // 2) see CFindCtf1D for using m_afResRange. 40 | //----------------------------------------------- 41 | float fPixSize = m_pCtfParam0->GetPixSize(); 42 | m_afResRange[0] = 20.0f * fPixSize; 43 | m_afResRange[1] = (2.0f * fPixSize) / 0.8f; 44 | if(m_afResRange[1] < 3.5f) m_afResRange[1] = 3.5f; 45 | } 46 | 47 | void CFindCtfBase::SetDfRange(float fDfRange) 48 | { 49 | m_fDfRange = fDfRange; 50 | } 51 | 52 | void CFindCtfBase::SetAstRange(float fAstRange) 53 | { 54 | m_fAstRange = fAstRange; 55 | } 56 | 57 | void CFindCtfBase::SetAngRange(float fAngRange) 58 | { 59 | m_fAngRange = fAngRange; 60 | } 61 | 62 | void CFindCtfBase::SetPhaseRange(float fPhaseRange) 63 | { 64 | m_fPhaseRange = fPhaseRange; 65 | } 66 | 67 | void CFindCtfBase::DoIt(float* gfSpect) 68 | { 69 | m_gfSpect = gfSpect; 70 | } 71 | 72 | CCtfParam* CFindCtfBase::GetResult(void) 73 | { 74 | CCtfParam* pRetParam = new CCtfParam; 75 | pRetParam->Setup(m_pCtfParamN); 76 | return pRetParam; 77 | } 78 | 79 | void CFindCtfBase::GetResRange(float* pfResRange) 80 | { 81 | pfResRange[0] = m_afResRange[0]; 82 | pfResRange[1] = m_afResRange[1]; 83 | } 84 | 85 | void CFindCtfBase::mGetDfRange(float fInitDf, float fDfRange, float* pfDfRange) 86 | { 87 | float fPixSize = m_pCtfParam0->GetPixSize(); 88 | float fPixSize2 = fPixSize * fPixSize; 89 | float fDfMin = 1000.0f * fPixSize2; 90 | float fDfMax = 30000.0f * fPixSize2; 91 | if(fDfMin < 1000.0f) fDfMin = 1000.0f; 92 | //---------------------------------- 93 | pfDfRange[0] = fmaxf(fInitDf - 0.5f * fDfRange, fDfMin); 94 | pfDfRange[1] = fminf(pfDfRange[0] + fDfRange, fDfMax); 95 | } 96 | 97 | void CFindCtfBase::mGetPhaseRange 98 | ( float fInitPhase, 99 | float fPhaseRange, 100 | float* pfPhaseRange 101 | ) 102 | { pfPhaseRange[0] = fmaxf(fInitPhase - 0.5f * fPhaseRange, 0.0f); 103 | pfPhaseRange[1] = fmin(pfPhaseRange[0] + fPhaseRange, 180.0f); 104 | } 105 | 106 | -------------------------------------------------------------------------------- /FindCtf/CFindCtfHelp.cpp: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | 3 | using namespace MotionCor2::FindCtf; 4 | 5 | float CFindCtfHelp::CalcAstRatio(float fDfMin, float fDfMax) 6 | { 7 | float fDiff = (fDfMax - fDfMin) * 0.5f; 8 | float fMean = (fDfMax + fDfMin) * 0.5f; 9 | if(fMean <= 0.0f) return 0.0f; 10 | else return (fDiff / fMean); 11 | } 12 | 13 | float CFindCtfHelp::CalcDfMin(float fDfMean, float fAstRatio) 14 | { 15 | float fDfMin = fDfMean * (1.0f - fAstRatio); 16 | return fDfMin; 17 | } 18 | 19 | float CFindCtfHelp::CalcDfMax(float fDfMean, float fAstRatio) 20 | { 21 | float fDfMax = fDfMean * (1.0f + fAstRatio); 22 | return fDfMax; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /FindCtf/CFullSpectrum.cpp: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include "../Util/CUtilInc.h" 3 | #include "../MrcUtil/CMrcUtilInc.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace MotionCor2::FindCtf; 12 | 13 | CFullSpectrum::CFullSpectrum(void) 14 | { 15 | m_gfFullSpect = 0L; // does not own it, do NOT clean 16 | } 17 | 18 | CFullSpectrum::~CFullSpectrum(void) 19 | { 20 | } 21 | 22 | void CFullSpectrum::ToHost(float* pfFullSpect) 23 | { 24 | size_t tBytes = sizeof(float) * m_aiFullSize[0] * m_aiFullSize[1]; 25 | cudaMemcpy(pfFullSpect, m_gfFullSpect, tBytes, cudaMemcpyDefault); 26 | } 27 | 28 | void CFullSpectrum::Create 29 | ( float* gfHalfSpect, 30 | float* gfCtfBuf, 31 | int* piSpectSize, 32 | CCtfParam* pCtfParam, 33 | float* pfResRange, 34 | float* gfFullSpect 35 | ) 36 | { m_aiSpectSize[0] = piSpectSize[0]; 37 | m_aiSpectSize[1] = piSpectSize[1]; 38 | m_afResRange[0] = pfResRange[0]; 39 | m_afResRange[1] = pfResRange[1]; 40 | //----------------- 41 | m_pCtfParam = pCtfParam; 42 | m_gfHalfSpect = gfHalfSpect; 43 | m_gfCtfBuf = gfCtfBuf; 44 | m_gfFullSpect = gfFullSpect; 45 | //----------------- 46 | m_aiFullSize[0] = (m_aiSpectSize[0] - 1) * 2; 47 | m_aiFullSize[1] = m_aiSpectSize[1]; 48 | //----------------- 49 | mGenFullSpectrum(); 50 | if(m_pCtfParam != 0L) mEmbedCTF(); 51 | } 52 | /* 53 | void CFullSpectrum::EmbedCTF 54 | ( float* gfFullSpect, int* piFullSize, bool bPadded, 55 | CCtfParam* pCtfParam, float* pfResRange 56 | ) 57 | { 58 | } 59 | */ 60 | void CFullSpectrum::mGenFullSpectrum(void) 61 | { 62 | GCalcSpectrum gCalcSpect; 63 | bool bFullPadded = true; 64 | gCalcSpect.GenFullSpect(m_gfHalfSpect, m_aiSpectSize, 65 | m_gfFullSpect, !bFullPadded); 66 | //----------------- 67 | Util::GCalcMoment2D gCalcMoment; 68 | bool bSync = true, bPadded = true; 69 | gCalcMoment.SetSize(m_aiSpectSize, !bPadded); 70 | m_fMean = gCalcMoment.DoIt(m_gfHalfSpect, 1, bSync); 71 | m_fStd = gCalcMoment.DoIt(m_gfHalfSpect, 2, bSync); 72 | m_fStd = m_fStd - m_fMean * m_fMean; 73 | if(m_fStd < 0) m_fStd = 0.0f; 74 | else m_fStd = sqrt(m_fStd); 75 | } 76 | /* 77 | void CFullSpectrum::mEmbedCTF(void) 78 | { 79 | float fPixelSize = m_pCtfParam->GetPixSize(); 80 | float fMinFreq = fPixelSize / m_afResRange[0]; 81 | float fMaxFreq = fPixelSize / m_afResRange[1]; 82 | float fGain = m_fStd * 1.5f; 83 | //-------------------------- 84 | GCalcCTF2D gCalcCtf2D; 85 | gCalcCtf2D.DoIt(m_pCtfParam, m_gfCtfBuf, m_aiSpectSize); 86 | gCalcCtf2D.EmbedCtf(m_gfCtfBuf, fMinFreq, fMaxFreq, 87 | m_fMean, fGain, m_gfFullSpect, m_aiSpectSize); 88 | } 89 | */ 90 | -------------------------------------------------------------------------------- /FindCtf/CFullSpectrum.o: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/czimaginginstitute/MotionCor3/f2cc4b1772f140fb44741502d4102a0e9f248ed2/FindCtf/CFullSpectrum.o -------------------------------------------------------------------------------- /FindCtf/CRescaleImage.cpp: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include "../CMainInc.h" 3 | #include "../Util/CUtilInc.h" 4 | #include "../MrcUtil/CMrcUtilInc.h" 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | using namespace MotionCor2; 12 | using namespace MotionCor2::FindCtf; 13 | namespace DU = MotionCor2::DataUtil; 14 | 15 | CRescaleImage::CRescaleImage(void) 16 | { 17 | m_gfPadImgN = 0L; 18 | m_fPixSizeN = 1.0f; 19 | memset(m_aiImgSizeN, 0, sizeof(m_aiImgSizeN)); 20 | memset(m_aiPadSizeN, 0, sizeof(m_aiPadSizeN)); 21 | } 22 | 23 | CRescaleImage::~CRescaleImage(void) 24 | { 25 | } 26 | 27 | void CRescaleImage::DoIt 28 | ( float* gfImg, int* piImgSize, 29 | DU::CDataPackage* pPackage 30 | ) 31 | { float fPixSize = pPackage->m_pAlnSums->m_fPixSize; 32 | //--------------------------- 33 | m_fBinning = 1.25f / fPixSize; 34 | if(m_fBinning <= 1) m_fBinning = 1.0f; 35 | m_fPixSizeN = fPixSize * m_fBinning; 36 | //--------------------------- 37 | m_aiImgSizeN[0] = (int)(piImgSize[0] / m_fBinning + 0.5f); 38 | m_aiImgSizeN[1] = (int)(piImgSize[1] / m_fBinning + 0.5f); 39 | m_aiImgSizeN[0] = m_aiImgSizeN[0] / 2 * 2; 40 | m_aiImgSizeN[1] = m_aiImgSizeN[1] / 2 * 2; 41 | //--------------------------- 42 | m_aiPadSizeN[0] = (m_aiImgSizeN[0] / 2 + 1) * 2; 43 | m_aiPadSizeN[1] = m_aiImgSizeN[1]; 44 | //--------------------------- 45 | int iBytes = sizeof(float) * m_aiPadSizeN[0] * m_aiPadSizeN[1]; 46 | if(m_gfPadImgN != 0L) cudaFree(m_gfPadImgN); 47 | cudaMalloc(&m_gfPadImgN, iBytes); 48 | //--------------------------- 49 | Util::GPad2D pad2D; 50 | if(m_fBinning == 1) 51 | { pad2D.Pad(gfImg, piImgSize, m_gfPadImgN, 0); 52 | return; 53 | } 54 | //--------------------------- 55 | CBufferPool* pBufPool = CBufferPool::GetInstance(); 56 | CStackBuffer* pTmpBuffer = pBufPool->GetBuffer(EBuffer::tmp); 57 | cufftComplex* gCmpBuf = pTmpBuffer->GetFrame(0, 0); 58 | pad2D.Pad(gfImg, piImgSize, (float*)gCmpBuf, 0); 59 | //--------------------------- 60 | Util::CCufft2D* pForFFT = pBufPool->GetForwardFFT(0); 61 | pForFFT->CreateForwardPlan(piImgSize, false); 62 | pForFFT->Forward((float*)gCmpBuf, true); 63 | //--------------------------- 64 | Util::GFourierResize2D fftResize; 65 | int aiCmpSize[] = {piImgSize[0] / 2 + 1, piImgSize[1]}; 66 | int aiCmpSizeN[] = {m_aiImgSizeN[0] / 2 + 1, m_aiImgSizeN[1]}; 67 | cufftComplex* gCmpImgN = (cufftComplex*)m_gfPadImgN; 68 | fftResize.DoIt(gCmpBuf, aiCmpSize, gCmpImgN, aiCmpSizeN, 0); 69 | //--------------------------- 70 | Util::CCufft2D* pInvFFT = pBufPool->GetInverseFFT(0); 71 | pInvFFT->CreateInversePlan(m_aiImgSizeN, false); 72 | pInvFFT->Inverse(gCmpImgN); 73 | } 74 | 75 | -------------------------------------------------------------------------------- /FindCtf/CSaveCtfResults.cpp: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include "../CInput.h" 3 | #include 4 | #include 5 | 6 | using namespace MotionCor2::FindCtf; 7 | 8 | CSaveCtfResults* CSaveCtfResults::m_pInstance = 0L; 9 | static float s_fD2R = 0.017453f; 10 | 11 | CSaveCtfResults* CSaveCtfResults::GetInstance(void) 12 | { 13 | if(m_pInstance != 0L) return m_pInstance; 14 | m_pInstance = new CSaveCtfResults; 15 | return m_pInstance; 16 | } 17 | 18 | void CSaveCtfResults::DeleteInstance(void) 19 | { 20 | if(m_pInstance == 0L) return; 21 | delete m_pInstance; 22 | m_pInstance = 0L; 23 | } 24 | 25 | CSaveCtfResults::CSaveCtfResults(void) 26 | { 27 | } 28 | 29 | CSaveCtfResults::~CSaveCtfResults(void) 30 | { 31 | } 32 | 33 | void CSaveCtfResults::AsyncSave(void) 34 | { 35 | this->WaitForExit(-1.0f); 36 | this->Start(); 37 | } 38 | 39 | void CSaveCtfResults::ThreadMain(void) 40 | { 41 | CInput* pInput = CInput::GetInstance(); 42 | Util::CFileName aInputName(pInput->m_acInMrcFile); 43 | Util::CFileName aOutputName(pInput->m_acOutMrcFile); 44 | aInputName.GetName(m_acInMrcFile); 45 | aOutputName.GetFolder(m_acOutFolder); 46 | //----------------------------------- 47 | mSaveImages(); 48 | mSaveFittings(); 49 | } 50 | 51 | void CSaveCtfResults::mSaveImages(void) 52 | { 53 | CCtfResults* pCtfResults = CCtfResults::GetInstance(); 54 | Mrc::CSaveMrc aSaveMrc; 55 | bool bClean = true; 56 | //---------------------------------------------------- 57 | char acCtfImgFile[256] = {'\0'}; 58 | strcpy(acCtfImgFile, m_acOutFolder); 59 | strcat(acCtfImgFile, m_acInMrcFile); 60 | strcat(acCtfImgFile, "_Ctf.mrc"); 61 | //---------------------------------------- 62 | aSaveMrc.OpenFile(acCtfImgFile); 63 | aSaveMrc.SetMode(Mrc::eMrcFloat); 64 | aSaveMrc.SetImgSize(pCtfResults->m_aiSpectSize, 65 | pCtfResults->m_iNumImgs, 1, 1.0f); 66 | //----------------------------------- 67 | for(int i=0; im_iNumImgs; i++) 68 | { float* pfSpect = pCtfResults->GetSpect(i, bClean); 69 | aSaveMrc.DoIt(i, pfSpect); 70 | if(pfSpect != 0L) delete[] pfSpect; 71 | } 72 | aSaveMrc.CloseFile(); 73 | } 74 | 75 | void CSaveCtfResults::mSaveFittings(void) 76 | { 77 | CCtfResults* pCtfResults = CCtfResults::GetInstance(); 78 | char acCtfTxtFile[256] = {'\0'}; 79 | strcpy(acCtfTxtFile, m_acOutFolder); 80 | strcat(acCtfTxtFile, m_acInMrcFile); 81 | strcat(acCtfTxtFile, "_Ctf.txt"); 82 | //------------------------------- 83 | FILE* pFile = fopen(acCtfTxtFile, "w"); 84 | if(pFile == 0L) return; 85 | //--------------------- 86 | fprintf(pFile, "# Columns: #1 micrograph number; " 87 | "#2 - defocus 1 [A]; #3 - defocus 2; " 88 | "#4 - azimuth of astigmatism; " 89 | "#5 - additional phase shift [radian]; " 90 | "#6 - cross correlation; " 91 | "#7 - spacing (in Angstroms) up to which CTF rings were " 92 | "fit successfully\n"); 93 | for(int i=0; im_iNumImgs; i++) 94 | { fprintf(pFile, "%4d %6.2f %8.2f %8.2f %8.2f " 95 | "%7.2f %8.4f\n", i+1, 96 | pCtfResults->GetDfMax(i), 97 | pCtfResults->GetDfMin(i), 98 | pCtfResults->GetAzimuth(i), 99 | pCtfResults->GetExtPhase(i) * s_fD2R, 100 | pCtfResults->GetScore(i), 101 | pCtfResults->GetCtfRes(i)); 102 | } 103 | fclose(pFile); 104 | } 105 | -------------------------------------------------------------------------------- /FindCtf/GCalcCTF1D.cu: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace MotionCor2::FindCtf; 7 | 8 | //----------------------------------------------------------------------------- 9 | // 1. Calculate theoretical CTF given the CTF parameters. 10 | // 0: wavelength in pixel 11 | // 1: Cs in pixel 12 | // 2: amplitude contrast contributed phase 13 | //----------------------------------------------------------------------------- 14 | static __device__ __constant__ float s_gfCtfParam[2]; 15 | 16 | static __global__ void mGCalculate 17 | ( float fDefocus, // in pixel 18 | float fExtPhase, // extra phase from amp contrast and phase plate 19 | float* gfCTF1D, 20 | int iCmpSize 21 | ) 22 | { int i = blockIdx.x * blockDim.x + threadIdx.x; 23 | if(i >= iCmpSize) return; 24 | //----------------------- 25 | float fs2 = (i * 0.5f) / (iCmpSize - 1.0f); 26 | fs2 = fs2 * fs2; 27 | float fw2 = s_gfCtfParam[0] * s_gfCtfParam[0]; 28 | fw2 = fExtPhase + 3.141592654f * s_gfCtfParam[0] * fs2 29 | * (fDefocus - 0.5f * fw2 * fs2 * s_gfCtfParam[1]); 30 | //--------------------------------------------------- 31 | gfCTF1D[i] = -sinf(fw2); 32 | } 33 | 34 | GCalcCTF1D::GCalcCTF1D(void) 35 | { 36 | } 37 | 38 | GCalcCTF1D::~GCalcCTF1D(void) 39 | { 40 | } 41 | 42 | void GCalcCTF1D::SetParam(CCtfParam* pCtfParam) 43 | { 44 | float afCtfParam[2] = {0.0f}; 45 | afCtfParam[0] = pCtfParam->m_fWaveLen; 46 | afCtfParam[1] = pCtfParam->m_fCs; 47 | cudaMemcpyToSymbol(s_gfCtfParam, afCtfParam, sizeof(float) * 2); 48 | m_fAmpPhase = pCtfParam->m_fAmpPhaseShift; 49 | } 50 | 51 | void GCalcCTF1D::DoIt 52 | ( float fDefocus, // in pixel 53 | float fExtPhase, // phase in radian from phase plate 54 | float* gfCTF1D, 55 | int iCmpSize 56 | ) 57 | { dim3 aBlockDim(512, 1); 58 | dim3 aGridDim(1, 1); 59 | aGridDim.x = (iCmpSize + aBlockDim.x - 1) / aBlockDim.x; 60 | float fAddPhase = m_fAmpPhase + fExtPhase; 61 | mGCalculate<<>>(fDefocus, fAddPhase, 62 | gfCTF1D, iCmpSize); 63 | } 64 | -------------------------------------------------------------------------------- /FindCtf/GRadialAvg.cu: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace MotionCor2::FindCtf; 7 | 8 | //----------------------------------------------------------------------------- 9 | //----------------------------------------------------------------------------- 10 | static __global__ void mGRadAverage 11 | ( float* gfSpectrum, 12 | float* gfAverage, 13 | int iCmpX, 14 | int iCmpY 15 | ) 16 | { int r = blockIdx.x * blockDim.x + threadIdx.x; 17 | if(r >= iCmpX) return; 18 | //-------------------- 19 | int iPoints = (int)(3.1415926f * r + 0.5f); 20 | if(iPoints < 1) iPoints = 1; 21 | else if(iPoints > 180) iPoints = 180; 22 | float fSum = 0.0f; 23 | float fAngStep = 180.0f / iPoints; 24 | //-------------------------------- 25 | for(int i=0; i>>(gfSpect, gfAverage, 51 | piCmpSize[0], piCmpSize[1]); 52 | } 53 | 54 | -------------------------------------------------------------------------------- /FindCtf/GRmBackground2D.cu: -------------------------------------------------------------------------------- 1 | #include "CFindCtfInc.h" 2 | #include 3 | #include 4 | 5 | using namespace MotionCor2::FindCtf; 6 | 7 | //----------------------------------------------------------------------------- 8 | // 1. gfIntSpect is shifted with its DC at (0, iCmpY/2). 9 | // 2. See GCalcSpectrum.cu kernel mGCalculate. 10 | //----------------------------------------------------------------------------- 11 | static __global__ void mGRemove 12 | ( float* gfInSpect, 13 | float* gfOutSpect, 14 | int iCmpY, 15 | int iBoxSize 16 | ) 17 | { int y = blockIdx.y * blockDim.y + threadIdx.y; 18 | if(y >= iCmpY) return; 19 | int i = y * gridDim.x + blockIdx.x; 20 | //--------------------------------- 21 | int iHalfX = gridDim.x - 1; 22 | int iHalfY = iCmpY / 2; 23 | //------------------------- 24 | y -= iHalfY; 25 | float fR = blockIdx.x * 0.5f / (gridDim.x - 1); 26 | fR = sqrtf(fR * fR + y * y / (float)(iCmpY * iCmpY)); 27 | if(fR < 0.04) 28 | { gfOutSpect[i] = 0.0f; 29 | return; 30 | } 31 | //-------------------------------------------------------- 32 | // (iX, iY): origin at lower left corner 33 | // (xxm yy): origin at iX = 0, iY = iHalfY 34 | // (xx = 0, yy=0) and (iX = 0, iY=iHalfY) is DC component 35 | //-------------------------------------------------------- 36 | int iX = 0, iY = 0; 37 | int iHalfBox = iBoxSize / 2; 38 | float fBackground = 0.0f; 39 | for(int k=-iHalfBox; k<=iHalfBox; k++) 40 | { int yy = k + y; 41 | for(int j=-iHalfBox; j<=iHalfBox; j++) 42 | { int xx = j + blockIdx.x; 43 | if(xx >= iHalfX) xx = xx - 2 * iHalfX; 44 | if(xx >= 0) 45 | { iX = xx; 46 | iY = iHalfY + yy; 47 | } 48 | else 49 | { iX = -xx; 50 | iY = iHalfY - yy; 51 | } 52 | if(iY < 0) iY += iCmpY; 53 | else if(iY >= iCmpY) iY -= iCmpY; 54 | //------------------------------- 55 | iX = iY * gridDim.x + iX; 56 | fBackground += sqrtf(gfInSpect[iX]); 57 | } 58 | } 59 | fBackground /= (iBoxSize * iBoxSize); 60 | fBackground = (fBackground * fBackground); 61 | gfOutSpect[i] = gfInSpect[i] - fBackground; 62 | } 63 | 64 | GRmBackground2D::GRmBackground2D(void) 65 | { 66 | } 67 | 68 | GRmBackground2D::~GRmBackground2D(void) 69 | { 70 | } 71 | 72 | //------------------------------------------------------------------------------ 73 | // 1. fBoxSize defines a square box where the mean is calculated. The mean is 74 | // then subtracted from the central pixel in the box. 75 | // 2. This operation is performed at each pixel. 76 | //------------------------------------------------------------------------------ 77 | void GRmBackground2D::DoIt 78 | ( float* gfInSpect, 79 | float* gfOutSpect, 80 | int* piCmpSize, 81 | int iBoxSize 82 | ) 83 | { dim3 aBlockDim(1, 512); 84 | dim3 aGridDim(piCmpSize[0], 1); 85 | aGridDim.y = piCmpSize[1] / aBlockDim.y; 86 | if((piCmpSize[1] % aBlockDim.y) > 0) aGridDim.y++; 87 | //----------------- 88 | mGRemove<<>>(gfInSpect, gfOutSpect, 89 | piCmpSize[1], iBoxSize); 90 | } 91 | 92 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | Copyright 2023 Chan Zuckerberg Institute for Advanced Biological Imaging 2 | Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 3 | 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 4 | 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 5 | 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 6 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 7 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_DataFile.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | class Util_DataFile 6 | { 7 | public: 8 | 9 | Util_DataFile(void); 10 | 11 | ~Util_DataFile(void); 12 | 13 | bool ReadIt(char* pcFileName); 14 | float GetValue(int iRow, int iCol); 15 | 16 | int GetNumRows(void); 17 | 18 | int GetNumCols(void); 19 | 20 | float* GetNthRow(int iNthRow); /* out */ 21 | 22 | float* GetNthCol(int iNthCol); /* out */ 23 | 24 | private: 25 | 26 | ssize_t mGetFileSize(void); 27 | void mCloseFile(void); 28 | 29 | void mReadFile(void); 30 | 31 | void mParseFile(char* pcBuf, ssize_t iSize); 32 | 33 | void mDetNumRows(char* pcBuf); 34 | 35 | void mDetNumCols(void); 36 | 37 | int mDetNumElems(char* pcRow); 38 | 39 | char* mGetNthRow(int iNthRow); 40 | 41 | void mParseNthRow(int iNthRow); 42 | 43 | void mFreeBuffer(void); 44 | 45 | void mAllocBuffer(void); 46 | 47 | int m_iNumRows; 48 | 49 | int m_iNumCols; 50 | 51 | float* m_pfValues; 52 | 53 | char** m_ppcRows; 54 | 55 | int m_iFile; 56 | }; 57 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_FileName.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_FileName 4 | { 5 | public: 6 | 7 | Util_FileName(char* pcFileName); 8 | 9 | 10 | ~Util_FileName(void); 11 | 12 | //--------------------------------------------------------------- 13 | // Extract the string before file extension. For example, if the 14 | // input file name is "/temp/test.mrc", this method returns 15 | // "/temp/test". Do not free memory of returned string. 16 | //--------------------------------------------------------------- 17 | char* GetMainName(void); /* [out] */ 18 | 19 | //--------------------------------------------------------------- 20 | // Return the file extension. Do not free memory of returned 21 | // string. 22 | //--------------------------------------------------------------- 23 | char* GetExtName(void); /* [out] */ 24 | 25 | //--------------------------------------------------------------- 26 | // Insert a serial number before file extension. For example, if 27 | // the file name is "/temp/test.mrc" and the serial number is 28 | // 10, the return is "/temp/test0010.mrc". Caller free memory. 29 | //--------------------------------------------------------------- 30 | char* InsertSerial(int iSerial); /* out */ 31 | 32 | char* ReplaceExt(char* pcExt); /* out */ 33 | 34 | //--------------------------------------------------------------- 35 | // Append the text before the file extension. For example, if the 36 | // file name is "/temp/test.mrc" and the text is "tgt", the 37 | // return is "/temp/testtgt.mrc". Caller frees memory. 38 | //--------------------------------------------------------------- 39 | char* AppendText(char* pcText); /* [out] */ 40 | 41 | //--------------------------------------------------------------- 42 | // Returns the free space in GB of the drive where the file will 43 | // be written. 44 | //--------------------------------------------------------------- 45 | int GetFreeDiskSpace(void); 46 | 47 | private: 48 | 49 | void mSetFileName(char* pcFileName); 50 | 51 | char* m_pcFileName; 52 | 53 | char* m_pcMainName; 54 | 55 | char* m_pcExtName; 56 | }; 57 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_Folder.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_Folder 4 | { 5 | public: 6 | 7 | Util_Folder(void); 8 | 9 | ~Util_Folder(void); 10 | 11 | /* 12 | ** Return the folder path given the full path of a file. For 13 | ** example, this method returns "/home/temp" given the full path 14 | ** of "/home/temp/test.mrc". 15 | */ 16 | char* GetFolderPath(char* pcFullPath); /* [out] */ 17 | 18 | /* 19 | ** Check if the given folder path is valid. 20 | */ 21 | bool IsValid(char* pcFolderPath); 22 | 23 | /* 24 | ** Recursively create folders. 25 | */ 26 | void Create(char* pcFolderPath); 27 | 28 | private: 29 | 30 | void mCreateFolder(char* pcFolder); 31 | 32 | int mFindLastSlash(char* pcFolder); 33 | 34 | int mGetNumParentFolders(char* pcFolderPath); 35 | 36 | char* mGetNthParentFolder(char* pcFolderPath, int iNthParent); 37 | }; 38 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_LinEqs.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_LinEqs 4 | { 5 | public: 6 | Util_LinEqs(void); 7 | ~Util_LinEqs(void); 8 | bool DoIt 9 | ( float* pfCoeff, 10 | float* pfVals, 11 | int iDim 12 | ); 13 | void Test(void); 14 | private: 15 | bool mFindPivot 16 | ( float* pfCoeff, 17 | int iPiv 18 | ); 19 | void mSwapRows 20 | ( float* pfCoeff, 21 | float* pfVals, 22 | int iPiv 23 | ); 24 | void mNormalize 25 | ( float* pfCoeff, 26 | float* pfVals, 27 | int iPiv 28 | ); 29 | void mReduceRows 30 | ( float* pfCoeff, 31 | float* pfVals, 32 | int iPiv 33 | ); 34 | void mClean 35 | ( void 36 | ); 37 | int m_iDim; 38 | int* m_piColIdx; // column index 39 | int* m_piRowIdx; // row index 40 | int* m_piPivots; // Num pivots at each column 41 | 42 | }; 43 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_Number.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //============================================================================= 4 | // 5 | // This class parses string to integer and float. 6 | // 7 | // Shawn Zheng, 01/24/2003 8 | // 9 | //============================================================================= 10 | class Util_Number 11 | { 12 | public: 13 | 14 | /* 15 | * Parse a string made of digits into a number. If the string 16 | * contains any letters except 0 to 9, +, -, and space, the 17 | * parsing fails. 18 | * 19 | * @return true if parsing success otherwise false. 20 | */ 21 | static bool ParseInt(char* pcVal, int& iOutVal); 22 | 23 | /* 24 | * Parse a string made of digits into a float number. If the 25 | * string contains any letters except 0 to 9, +, -, . and 26 | * space, the parsing fails. 27 | * 28 | * @return true if parsing success otherwise false. 29 | */ 30 | static bool ParseFloat(char* pcVal, float& fOutVal); 31 | 32 | /* 33 | * convert a real number into a string. 34 | */ 35 | static void ToString(double dNumber, char* pcStr); 36 | 37 | /* 38 | * convert a int number to a string 39 | */ 40 | static void ToString(int iNumber, char* pcStr); 41 | 42 | static int Round(double dVal); 43 | 44 | static bool mCheckString(char* pcVal); 45 | 46 | static bool mIsDigit(char c); 47 | 48 | static bool mIsSign(char c); 49 | 50 | static bool mIsSpace(char c); 51 | }; 52 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_Powell.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_Powell 4 | { 5 | public: 6 | Util_Powell(void); 7 | virtual ~Util_Powell(void); 8 | virtual float Eval(float* pfPoint); // must be overriden 9 | void Clean(void); 10 | void Setup(int iDim, int iIterations, float fTol); 11 | float DoIt 12 | ( float* pfInitPoint, 13 | float* pfSearchRange, 14 | int iNumSteps 15 | ); 16 | int m_iDim; 17 | float* m_pfInitPoint; 18 | float* m_pfBestPoint; 19 | float m_fInitVal; 20 | float m_fBestVal; 21 | private: 22 | float mDoIt(void); 23 | float mLineMinimize(float* pfPoint, float* pfVector); 24 | void mCalcNewPoint 25 | ( float* pfOldPoint, 26 | float* pfVector, 27 | float fStride, 28 | float* pfNewPoint 29 | ); 30 | void mNormVector(float* pfVector); 31 | void mFindAllowableRange 32 | ( float* pfStartPoint, 33 | float* pfVector, 34 | float* pfRange 35 | ); 36 | int m_iIterations; 37 | int m_iNumSteps; 38 | float m_fTol; 39 | float* m_pfPointMin; 40 | float* m_pfPointMax; 41 | float* m_pfVectors; 42 | float m_fTiny; 43 | }; 44 | 45 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_String.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_String 4 | { 5 | public: 6 | 7 | static void RemoveSpace(char* pcString); 8 | 9 | static char* GetCopy(char* pcString); 10 | 11 | }; 12 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_SwapByte.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_SwapByte 4 | { 5 | public: 6 | 7 | static short DoIt(short sData); 8 | 9 | static unsigned short DoIt(unsigned short sData); 10 | 11 | static int DoIt(int iData); 12 | 13 | static unsigned int DoIt(unsigned int iData); 14 | 15 | static float DoIt(float fData); 16 | 17 | static double DoIt(double dData); 18 | }; 19 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_Thread.h: -------------------------------------------------------------------------------- 1 | //============================================================================= 2 | // 3 | // On Linux, you must compile with the -D_REENTRANT option. This tells 4 | // the C/C++ libraries that the functions must be thread-safe 5 | // 6 | //============================================================================= 7 | #pragma once 8 | #include 9 | 10 | class Util_Thread 11 | { 12 | public: 13 | 14 | Util_Thread(void); 15 | virtual ~Util_Thread(); 16 | virtual void ThreadMain(void); 17 | void Start(void); 18 | void Stop(void); 19 | bool WaitForExit(float fSeconds); 20 | bool WaitSeconds(float fSeconds); 21 | bool IsAlive(void); 22 | bool IsCreated(void); 23 | private: 24 | static void* ThreadFunc(void* pvParam); 25 | protected: 26 | bool mWait(float fSeconds); 27 | pthread_t m_aThread; 28 | pthread_cond_t m_aCond; 29 | pthread_mutex_t m_aMutex; 30 | bool m_bCreated; 31 | bool m_bStop; 32 | }; 33 | 34 | -------------------------------------------------------------------------------- /LibSrc/Include/Util/Util_Time.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | class Util_Time 6 | { 7 | public: 8 | 9 | void Measure(void); 10 | 11 | float GetElapsedSeconds(void); 12 | 13 | private: 14 | 15 | struct timeval m_aTimeval; 16 | 17 | }; 18 | 19 | -------------------------------------------------------------------------------- /LibSrc/Lib/libmrcfile.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/czimaginginstitute/MotionCor3/f2cc4b1772f140fb44741502d4102a0e9f248ed2/LibSrc/Lib/libmrcfile.a -------------------------------------------------------------------------------- /LibSrc/Lib/libutil.a: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/czimaginginstitute/MotionCor3/f2cc4b1772f140fb44741502d4102a0e9f248ed2/LibSrc/Lib/libutil.a -------------------------------------------------------------------------------- /LibSrc/Mrcfile/App/CFindMrc.cpp: -------------------------------------------------------------------------------- 1 | #include "../Include/LoadMainHeader.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace Mrc; 10 | 11 | CFindMrc::CFindMrc() 12 | { 13 | m_pcFileName = new char[256]; 14 | m_iNumSections = 0; 15 | } 16 | 17 | CFindMrc::~CFindMrc() 18 | { 19 | if(m_pcFileName != NULL) delete[] m_pcFileName; 20 | } 21 | 22 | void CFindMrc::SetFileName(char* pcFileName) 23 | { 24 | strcpy(m_pcFileName, ""); 25 | m_iNumSections = 0; 26 | if(pcFileName == NULL) return; 27 | else strcpy(m_pcFileName, pcFileName); 28 | //------------------------------------ 29 | int iFile = mOpenFile(m_cFileName); 30 | if(iFile == -1) return; 31 | //--------------------- 32 | CLoadMainHeader aLoadMain; 33 | aLoadMain.DoIt(iFile); 34 | m_iNumSections = aLoadMain.GetSizeZ(); 35 | close(iFile); 36 | } 37 | 38 | int CFindMrc::FindFromStage(float fStageX, float fStageY) 39 | { 40 | int iFile = mOpenFile(); 41 | if(iFile == -1) return -1; 42 | //------------------------ 43 | CLoadExtHeader aLoadExt; 44 | aLoadExt.SetFile(iFile); 45 | //---------------------- 46 | int iSection = -1; 47 | double dMin = 1e30; 48 | float afStage[2] = {0.0f}; 49 | //------------------------ 50 | for(int i=0; i 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | using namespace Mrc; 11 | 12 | CLoadMrc::CLoadMrc() 13 | { 14 | m_pLoadMain = new CLoadMainHeader; 15 | m_pLoadExt = new CLoadExtHeader; 16 | m_pLoadImg = new CLoadImage; 17 | m_iFile = -1; 18 | m_fPixelSize = 0.0f; 19 | } 20 | 21 | CLoadMrc::~CLoadMrc() 22 | { 23 | this->CloseFile(); 24 | if(m_pLoadMain != 0L) delete m_pLoadMain; 25 | if(m_pLoadExt != 0L) delete m_pLoadExt; 26 | if(m_pLoadImg != 0L) delete m_pLoadImg; 27 | } 28 | 29 | bool CLoadMrc::OpenFile(char* pcFileName) 30 | { 31 | this->CloseFile(); 32 | if(pcFileName == NULL || strlen(pcFileName) == 0) return false; 33 | m_iFile = open(pcFileName, O_RDONLY); 34 | if(m_iFile == -1) return false; 35 | //----------------------------- 36 | m_pLoadMain->DoIt(m_iFile); 37 | m_pLoadExt->SetFile(m_iFile); 38 | m_pLoadImg->SetFile(m_iFile); 39 | //--------------------------- 40 | m_fPixelSize = m_pLoadMain->GetPixelSize(); 41 | if(m_fPixelSize <= 0.01f) 42 | { m_pLoadExt->DoIt(0); 43 | m_fPixelSize = m_pLoadExt->GetPixelSize(); 44 | } 45 | //------------------------------------------------ 46 | return true; 47 | } 48 | 49 | bool CLoadMrc::OpenFile(wchar_t* pwcFileName) 50 | { 51 | this->CloseFile(); 52 | if(pwcFileName == 0L) return false; 53 | int iSize = wcslen(pwcFileName); 54 | if(iSize == 0L) return false; 55 | //--------------------------- 56 | char* pcFile = new char[iSize + 1]; 57 | for(int i=0; iOpenFile(pcFile); 61 | if(pcFile != 0L) delete[] pcFile; 62 | return bOpen; 63 | } 64 | 65 | bool CLoadMrc::OpenFile(char* pcFileName, int iSerialNum) 66 | { 67 | this->CloseFile(); 68 | if(pcFileName == NULL) return false; 69 | if(strlen(pcFileName) == 0) return false; 70 | //--------------------------------------- 71 | Util_FileName aUtilFileName(pcFileName); 72 | char* pcSerialFileName = aUtilFileName.InsertSerial(iSerialNum); 73 | bool bOpen = this->OpenFile(pcSerialFileName); 74 | delete[] pcSerialFileName; 75 | return bOpen; 76 | } 77 | 78 | bool CLoadMrc::OpenFile(wchar_t* pwcFileName, int iSerialNum) 79 | { 80 | this->CloseFile(); 81 | if(pwcFileName == 0L) return false; 82 | int iSize = wcslen(pwcFileName); 83 | if(iSize == 0L) return false; 84 | //--------------------------- 85 | char* pcFile = new char[iSize + 1]; 86 | for(int i=0; iOpenFile(pcFile, iSerialNum); 90 | if(pcFile != 0L) delete[] pcFile; 91 | return bOpen; 92 | } 93 | 94 | void CLoadMrc::CloseFile(void) 95 | { 96 | if(m_iFile == -1) return; 97 | close(m_iFile); 98 | m_iFile = -1; 99 | } 100 | 101 | float CLoadMrc::GetPixelSize(void) 102 | { 103 | return m_fPixelSize; 104 | } 105 | 106 | -------------------------------------------------------------------------------- /LibSrc/Mrcfile/App/CMrcScale.cpp: -------------------------------------------------------------------------------- 1 | #include "../Include/CMrcFileInc.h" 2 | 3 | using namespace Mrc; 4 | 5 | CMrcScale::CMrcScale(void) 6 | { 7 | m_iPixels = 0; 8 | m_fScale = 1.0f; 9 | } 10 | 11 | CMrcScale::~CMrcScale(void) 12 | { 13 | } 14 | 15 | void CMrcScale::Setup(int iNewMode, float fScale) 16 | { 17 | m_iNewMode = iNewMode; 18 | m_fScale = fScale; 19 | } 20 | 21 | void* CMrcScale::DoIt(float* pfData, int iPixels) 22 | { 23 | int iPixBytes = CMrcModes::GetBits(m_iNewMode) / 8; 24 | void* pvData = new char[iPixels * iPixBytes]; 25 | this->DoIt(pfData, iPixels, pvData); 26 | return pvData; 27 | } 28 | 29 | void CMrcScale::DoIt(float* pfData, int iPixels, void* pvData) 30 | { 31 | m_iPixels = iPixels; 32 | if(m_iNewMode == Mrc::eMrcUChar) mToUChar(pfData, pvData); 33 | else if(m_iNewMode == Mrc::eMrcUCharEM) mToUChar(pfData, pvData); 34 | else if(m_iNewMode == Mrc::eMrcShort) mToShort(pfData, pvData); 35 | else if(m_iNewMode == Mrc::eMrcUShort) mToUShort(pfData, pvData); 36 | else if(m_iNewMode == Mrc::eMrcInt) mToInt(pfData, pvData); 37 | else if(m_iNewMode == Mrc::eMrcFloat) mToFloat(pfData, pvData); 38 | } 39 | 40 | void CMrcScale::mToUChar(float* pfData, void* pvData) 41 | { 42 | unsigned char* pucBuf = (unsigned char*)pvData; 43 | for(int i=0; i 255) pucBuf[i] = 255; 47 | else pucBuf[i] = (unsigned char)iVal; 48 | } 49 | } 50 | 51 | void CMrcScale::mToShort(float* pfData, void* pvData) 52 | { 53 | short* psBuf = (short*)pvData; 54 | for(int i=0; i 32767) psBuf[i] = 32767; 57 | else if(iVal < -32767) psBuf[i] = -32767; 58 | else psBuf[i] = (short)iVal; 59 | } 60 | } 61 | 62 | void CMrcScale::mToUShort(float* pfData, void* pvData) 63 | { 64 | unsigned short* psBuf = (unsigned short*)pvData; 65 | for(int i=0; i 65535) psBuf[i] = 65535; 68 | else if(iVal < 0) psBuf[i] = 0; 69 | else psBuf[i] = (unsigned short)iVal; 70 | } 71 | } 72 | 73 | void CMrcScale::mToInt(float* pfData, void* pvData) 74 | { 75 | int* piBuf = (int*)pvData; 76 | for(int i=0; i 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | using namespace Mrc; 11 | 12 | CReviseExtHeader::CReviseExtHeader(void) 13 | { 14 | m_iFile = -1; 15 | m_iHeader = -1; 16 | } 17 | 18 | CReviseExtHeader::~CReviseExtHeader() 19 | { 20 | this->CloseFile(); 21 | } 22 | 23 | bool CReviseExtHeader::OpenFile(char* pcFileName) 24 | { 25 | m_iHeader = -1; 26 | this->CloseFile(); 27 | //---------------- 28 | mode_t aMode = S_IRUSR | S_IWUSR | S_IWGRP | S_IRGRP | S_IROTH; 29 | m_iFile = open(pcFileName, O_RDWR, aMode); 30 | if(m_iFile == -1) return false; 31 | //----------------------------- 32 | m_aLoadExt.SetFile(m_iFile); 33 | m_aSaveExt.SetFile(m_iFile); 34 | m_aSaveExt.Setup(m_aLoadExt.m_iNumInts, m_aLoadExt.m_iNumFloats, 35 | m_aLoadExt.m_aiImgSize[2]); 36 | return true; 37 | } 38 | 39 | bool CReviseExtHeader::OpenFile(wchar_t* pwcFileName) 40 | { 41 | this->CloseFile(); 42 | if(pwcFileName == 0L) return false; 43 | int iSize = wcslen(pwcFileName); 44 | if(iSize == 0) return false; 45 | //-------------------------- 46 | char* pcFile = new char[iSize + 1]; 47 | for(int i=0; iOpenFile(pcFile); 51 | if(pcFile != 0L) delete[] pcFile; 52 | return bOpen; 53 | } 54 | 55 | void CReviseExtHeader::CloseFile(void) 56 | { 57 | if(m_iFile == -1) return; 58 | close(m_iFile); 59 | m_iFile = -1; 60 | } 61 | 62 | void CReviseExtHeader::Load(int iNthHeader) 63 | { 64 | if(m_iHeader == iNthHeader) return; 65 | m_iHeader = iNthHeader; 66 | m_aLoadExt.DoIt(iNthHeader); 67 | m_aSaveExt.SetHeader(m_iHeader, m_aLoadExt.m_pcHeader, 68 | m_aLoadExt.m_iHeaderSize); 69 | } 70 | 71 | void CReviseExtHeader::SetStage(float* pfStage, int iElems) 72 | { 73 | m_aSaveExt.SetStage(m_iHeader, pfStage, iElems); 74 | } 75 | 76 | void CReviseExtHeader::SetShift(float* pfShift, int iElems) 77 | { 78 | m_aSaveExt.SetShift(m_iHeader, pfShift, iElems); 79 | } 80 | 81 | void CReviseExtHeader::SetFloat(float fValue, int iField) 82 | { 83 | m_aSaveExt.SetNthFloat(m_iHeader, iField, fValue); 84 | } 85 | 86 | void CReviseExtHeader::Save(void) 87 | { 88 | if(m_iHeader == -1) return; 89 | if(m_iFile == -1) return; 90 | m_aSaveExt.DoIt(); 91 | } 92 | -------------------------------------------------------------------------------- /LibSrc/Mrcfile/Header/CLoadMainHeader.cpp: -------------------------------------------------------------------------------- 1 | #include "../Include/CMrcFileInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace Mrc; 9 | 10 | CLoadMainHeader::CLoadMainHeader(void) 11 | { 12 | } 13 | 14 | CLoadMainHeader::~CLoadMainHeader(void) 15 | { 16 | } 17 | 18 | void CLoadMainHeader::DoIt(int iFile) 19 | { 20 | m_bSwapByte = false; 21 | memset(&m_aHeader, 0, sizeof(CMainHeader)); 22 | if(iFile == -1) return; 23 | //--------------------- 24 | lseek64(iFile, 0, SEEK_SET); 25 | read(iFile, &m_aHeader, 1024); 26 | //---------------------------- 27 | int iMaxSize = 32 * 1024; 28 | if(m_aHeader.mode < 0) m_bSwapByte = true; 29 | else if(m_aHeader.nx < 0) m_bSwapByte = true; 30 | else if(m_aHeader.ny < 0) m_bSwapByte = true; 31 | else if(m_aHeader.nz < 0) m_bSwapByte = true; 32 | else if(m_aHeader.nz < 0) m_bSwapByte = true; 33 | else if(m_aHeader.nx > iMaxSize) m_bSwapByte = true; 34 | else if(m_aHeader.ny > iMaxSize) m_bSwapByte = true; 35 | else if(m_aHeader.nz > iMaxSize) m_bSwapByte = true; 36 | //-------------------------------------------------- 37 | if(m_bSwapByte) m_aHeader.SwapByte(); 38 | } 39 | 40 | int CLoadMainHeader::GetSizeX(void) 41 | { 42 | return m_aHeader.nx; 43 | } 44 | 45 | int CLoadMainHeader::GetSizeY(void) 46 | { 47 | return m_aHeader.ny; 48 | } 49 | 50 | int CLoadMainHeader::GetSizeZ(void) 51 | { 52 | return m_aHeader.nz; 53 | } 54 | 55 | void CLoadMainHeader::GetSize(int* piSize, int iElems) 56 | { 57 | if(iElems <= 0) return; 58 | piSize[0] = m_aHeader.nx; 59 | if(iElems > 1) piSize[1] = m_aHeader.ny; 60 | if(iElems > 2) piSize[2] = m_aHeader.nz; 61 | } 62 | 63 | int CLoadMainHeader::GetStackZ(void) 64 | { 65 | return m_aHeader.mz; 66 | } 67 | 68 | int CLoadMainHeader::GetMode(void) 69 | { 70 | return m_aHeader.mode; 71 | } 72 | 73 | int CLoadMainHeader::GetSymbt(void) 74 | { 75 | return m_aHeader.nsymbt; 76 | } 77 | 78 | int CLoadMainHeader::GetNumInts(void) 79 | { 80 | return m_aHeader.numintegers; 81 | } 82 | 83 | int CLoadMainHeader::GetNumFloats(void) 84 | { 85 | return m_aHeader.numfloats; 86 | } 87 | 88 | float CLoadMainHeader::GetLengthX(void) 89 | { 90 | return m_aHeader.xlen; 91 | } 92 | 93 | float CLoadMainHeader::GetLengthY(void) 94 | { 95 | return m_aHeader.ylen; 96 | } 97 | 98 | float CLoadMainHeader::GetMean(void) 99 | { 100 | return m_aHeader.amean; 101 | } 102 | 103 | float CLoadMainHeader::GetMax(void) 104 | { 105 | return m_aHeader.amax; 106 | } 107 | 108 | float CLoadMainHeader::GetMin(void) 109 | { 110 | return m_aHeader.amin; 111 | } 112 | 113 | char* CLoadMainHeader::GetNthLabel(int iNthLabel) 114 | { 115 | if(iNthLabel < 0 || iNthLabel > 9) return 0L; 116 | return m_aHeader.data[iNthLabel]; 117 | } 118 | 119 | float CLoadMainHeader::GetPixelSize(void) 120 | { 121 | if(m_aHeader.nx <= 0) return 0.0f; 122 | float fPixelSize = m_aHeader.xlen / m_aHeader.nx; 123 | return fPixelSize; 124 | } 125 | 126 | int CLoadMainHeader::GetGainBytes(void) 127 | { 128 | int iExtHeaderSize = m_aHeader.numfloats * sizeof(float) 129 | + m_aHeader.numintegers * sizeof(int); 130 | int iGainBytes = m_aHeader.nsymbt - m_aHeader.nz * iExtHeaderSize; 131 | return iGainBytes; 132 | } 133 | -------------------------------------------------------------------------------- /LibSrc/Mrcfile/Header/CMainHeader.cpp: -------------------------------------------------------------------------------- 1 | #include "../Include/CMrcFileInc.h" 2 | #include 3 | #include 4 | 5 | using namespace Mrc; 6 | 7 | CMainHeader::CMainHeader(void) 8 | { 9 | memset(this, 0, sizeof(CMainHeader)); 10 | } 11 | 12 | CMainHeader::~CMainHeader(void) 13 | { 14 | } 15 | 16 | void CMainHeader::SwapByte(void) 17 | { 18 | nx = Util_SwapByte::DoIt(nx); 19 | ny = Util_SwapByte::DoIt(ny); 20 | nz = Util_SwapByte::DoIt(nz); 21 | mode = Util_SwapByte::DoIt(mode); 22 | nxstart = Util_SwapByte::DoIt(nxstart); 23 | nystart = Util_SwapByte::DoIt(nystart); 24 | nzstart = Util_SwapByte::DoIt(nzstart); 25 | mx = Util_SwapByte::DoIt(mx); 26 | my = Util_SwapByte::DoIt(my); 27 | mz = Util_SwapByte::DoIt(mz); 28 | xlen = Util_SwapByte::DoIt(xlen); 29 | ylen = Util_SwapByte::DoIt(ylen); 30 | zlen = Util_SwapByte::DoIt(zlen); 31 | alpha = Util_SwapByte::DoIt(alpha); 32 | beta = Util_SwapByte::DoIt(beta); 33 | gamma = Util_SwapByte::DoIt(gamma); 34 | mapc = Util_SwapByte::DoIt(mapc); 35 | mapr = Util_SwapByte::DoIt(mapr); 36 | maps = Util_SwapByte::DoIt(maps); 37 | amin = Util_SwapByte::DoIt(amin); 38 | amax = Util_SwapByte::DoIt(amax); 39 | amean = Util_SwapByte::DoIt(amean); 40 | ispg = Util_SwapByte::DoIt(ispg); 41 | nsymbt = Util_SwapByte::DoIt(nsymbt); 42 | dvid = Util_SwapByte::DoIt(dvid); 43 | nblank = Util_SwapByte::DoIt(nblank); 44 | itst = Util_SwapByte::DoIt(itst); 45 | numintegers = Util_SwapByte::DoIt(numintegers); 46 | numfloats = Util_SwapByte::DoIt(numfloats); 47 | sub = Util_SwapByte::DoIt(sub); 48 | zfac = Util_SwapByte::DoIt(zfac); 49 | min2 = Util_SwapByte::DoIt(min2); 50 | max2 = Util_SwapByte::DoIt(max2); 51 | min3 = Util_SwapByte::DoIt(min3); 52 | max3 = Util_SwapByte::DoIt(max3); 53 | min4 = Util_SwapByte::DoIt(min4); 54 | max4 = Util_SwapByte::DoIt(max4); 55 | type = Util_SwapByte::DoIt(type); 56 | lensnum = Util_SwapByte::DoIt(lensnum); 57 | nd1 = Util_SwapByte::DoIt(nd1); 58 | nd2 = Util_SwapByte::DoIt(nd2); 59 | vd1 = Util_SwapByte::DoIt(vd1); 60 | vd2 = Util_SwapByte::DoIt(vd2); 61 | min5 = Util_SwapByte::DoIt(min5); 62 | max5 = Util_SwapByte::DoIt(max5); 63 | numtimes = Util_SwapByte::DoIt(numtimes); 64 | imgseq = Util_SwapByte::DoIt(imgseq); 65 | xtilt = Util_SwapByte::DoIt(xtilt); 66 | ytilt = Util_SwapByte::DoIt(ytilt); 67 | ztilt = Util_SwapByte::DoIt(ztilt); 68 | numwaves = Util_SwapByte::DoIt(numwaves); 69 | wave1 = Util_SwapByte::DoIt(wave1); 70 | wave2 = Util_SwapByte::DoIt(wave2); 71 | wave3 = Util_SwapByte::DoIt(wave3); 72 | wave4 = Util_SwapByte::DoIt(wave4); 73 | wave5 = Util_SwapByte::DoIt(wave5); 74 | z0 = Util_SwapByte::DoIt(z0); 75 | x0 = Util_SwapByte::DoIt(x0); 76 | y0 = Util_SwapByte::DoIt(y0); 77 | nlabl = Util_SwapByte::DoIt(nlabl); 78 | } 79 | -------------------------------------------------------------------------------- /LibSrc/Mrcfile/Image/C4BitImage.cpp: -------------------------------------------------------------------------------- 1 | #include "../Include/CMrcFileInc.h" 2 | #include 3 | #include 4 | 5 | using namespace Mrc; 6 | 7 | C4BitImage::C4BitImage(void) 8 | { 9 | } 10 | 11 | C4BitImage::~C4BitImage(void) 12 | { 13 | } 14 | 15 | int C4BitImage::GetPkdSize(int iSize) 16 | { 17 | return (iSize + 1) / 2; 18 | } 19 | 20 | void C4BitImage::GetPkdSize(int* piRawSize, int* piPkdSize) 21 | { 22 | piPkdSize[0] = C4BitImage::GetPkdSize(piRawSize[0]); 23 | piPkdSize[1] = piRawSize[1]; 24 | } 25 | 26 | size_t C4BitImage::GetImgBytes(int iMode, int* piRawSize) 27 | { 28 | size_t tImgBytes = 0; 29 | if(iMode == Mrc::eMrc4Bits) 30 | { int aiPkdSize[2] = {0}; 31 | GetPkdSize(piRawSize, aiPkdSize); 32 | tImgBytes = aiPkdSize[0]; 33 | tImgBytes *= (aiPkdSize[1] * sizeof(char)); 34 | } 35 | else 36 | { size_t tPixels = piRawSize[0] * piRawSize[1]; 37 | tImgBytes = CMrcModes::GetBits(iMode) / 8 * tPixels; 38 | } 39 | return tImgBytes; 40 | } 41 | 42 | size_t C4BitImage::GetLineBytes(int iMode, int iRawSize) 43 | { 44 | size_t tLineBytes = 0; 45 | if(iMode == Mrc::eMrc4Bits) 46 | { int iPkdSize = GetPkdSize(iRawSize); 47 | tLineBytes = iPkdSize * sizeof(char); 48 | } 49 | else 50 | { size_t tRawSize = iRawSize; 51 | tLineBytes = CMrcModes::GetBits(iMode) / 8 * tRawSize; 52 | } 53 | return tLineBytes; 54 | } 55 | 56 | void* C4BitImage::GetPkdBuf(int* piRawSize) 57 | { 58 | int aiPkdSize[2] = {0}; 59 | C4BitImage::GetPkdSize(piRawSize, aiPkdSize); 60 | int iPkdPixels = aiPkdSize[0] * aiPkdSize[1]; 61 | char* pcBuf = new char[iPkdPixels]; 62 | return pcBuf; 63 | } 64 | 65 | void* C4BitImage::Pack(void* pvRawImg, int* piRawSize) 66 | { 67 | void* pvPkdBuf = C4BitImage::GetPkdBuf(piRawSize); 68 | C4BitImage::Pack(pvRawImg, piRawSize, pvPkdBuf); 69 | return pvPkdBuf; 70 | } 71 | 72 | void C4BitImage::Pack(void* pvRawImg, int* piRawSize, void* pvPkdImg) 73 | { 74 | unsigned char* pucRaw = (unsigned char*)pvRawImg; 75 | unsigned char* pucPkd = (unsigned char*)pvPkdImg; 76 | int iPkdX = C4BitImage::GetPkdSize(piRawSize[0]); 77 | //----------------------------------------------- 78 | for(int y=0; y> 4) & 0xf; 104 | } 105 | } 106 | } 107 | 108 | -------------------------------------------------------------------------------- /LibSrc/Mrcfile/Image/CSaveImage.cpp: -------------------------------------------------------------------------------- 1 | #include "../Include/CMrcFileInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace Mrc; 8 | 9 | CSaveImage::CSaveImage(void) 10 | { 11 | m_iFile = -1; 12 | memset(m_aiImgSize, 0, sizeof(m_aiImgSize)); 13 | } 14 | 15 | CSaveImage::~CSaveImage(void) 16 | { 17 | } 18 | 19 | void CSaveImage::SetFile(int iFile) 20 | { 21 | m_iFile = iFile; 22 | } 23 | 24 | void CSaveImage::SetMode(int iMode) 25 | { 26 | m_iMode = iMode; 27 | } 28 | 29 | void CSaveImage::SetImgSize(int* piSize) 30 | { 31 | m_aiImgSize[0] = piSize[0]; 32 | m_aiImgSize[1] = piSize[1]; 33 | } 34 | 35 | void CSaveImage::SetSymbt(int iSymbt) 36 | { 37 | m_iSymbt = iSymbt; 38 | } 39 | 40 | void CSaveImage::DoIt(int iNthImage, void* pvImage) 41 | { 42 | if(m_iFile == -1) return; 43 | size_t tPixels = m_aiImgSize[0] * m_aiImgSize[1]; 44 | size_t tImgBytes = tPixels * CMrcModes::GetBits(m_iMode) / 8; 45 | //----------------------------------------------------------- 46 | off64_t tOffset = 1024 + m_iSymbt + iNthImage * tImgBytes; 47 | lseek64(m_iFile, tOffset, SEEK_SET); 48 | write(m_iFile, pvImage, tImgBytes); 49 | } 50 | 51 | void CSaveImage::DoIt(int iStartImg, int iNumImgs, void* pvImages) 52 | { 53 | if(m_iFile == -1) return; 54 | size_t tPixels = m_aiImgSize[0] * m_aiImgSize[1]; 55 | size_t tImgBytes = tPixels * CMrcModes::GetBits(m_iMode) / 8; 56 | size_t tTotalBytes = tImgBytes * iNumImgs; 57 | //---------------------------------------- 58 | off64_t tOffset = 1024 + m_iSymbt + iStartImg * tImgBytes; 59 | lseek64(m_iFile, tOffset, SEEK_SET); 60 | char* pcImg = (char*)pvImages; 61 | write(m_iFile, pcImg, tImgBytes); 62 | for(int i=1; i 4 | 5 | class Util_DataFile 6 | { 7 | public: 8 | 9 | Util_DataFile(void); 10 | 11 | ~Util_DataFile(void); 12 | 13 | bool ReadIt(char* pcFileName); 14 | float GetValue(int iRow, int iCol); 15 | 16 | int GetNumRows(void); 17 | 18 | int GetNumCols(void); 19 | 20 | float* GetNthRow(int iNthRow); /* out */ 21 | 22 | float* GetNthCol(int iNthCol); /* out */ 23 | 24 | private: 25 | 26 | ssize_t mGetFileSize(void); 27 | void mCloseFile(void); 28 | 29 | void mReadFile(void); 30 | 31 | void mParseFile(char* pcBuf, ssize_t iSize); 32 | 33 | void mDetNumRows(char* pcBuf); 34 | 35 | void mDetNumCols(void); 36 | 37 | int mDetNumElems(char* pcRow); 38 | 39 | char* mGetNthRow(int iNthRow); 40 | 41 | void mParseNthRow(int iNthRow); 42 | 43 | void mFreeBuffer(void); 44 | 45 | void mAllocBuffer(void); 46 | 47 | int m_iNumRows; 48 | 49 | int m_iNumCols; 50 | 51 | float* m_pfValues; 52 | 53 | char** m_ppcRows; 54 | 55 | int m_iFile; 56 | }; 57 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_FileName.cpp: -------------------------------------------------------------------------------- 1 | #include "Util_FileName.h" 2 | #include "Util_Number.h" 3 | #include "Util_String.h" 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | Util_FileName::Util_FileName(char* pcFileName) 12 | { 13 | mSetFileName(pcFileName); 14 | } 15 | 16 | Util_FileName::~Util_FileName(void) 17 | { 18 | delete[] m_pcFileName; 19 | } 20 | 21 | char* Util_FileName::GetMainName(void) 22 | { 23 | char* pcMainName = Util_String::GetCopy(m_pcMainName); 24 | return pcMainName; 25 | } 26 | 27 | char* Util_FileName::GetExtName(void) 28 | { 29 | char* pcExtName = Util_String::GetCopy(m_pcExtName); 30 | return pcExtName; 31 | } 32 | 33 | char* Util_FileName::InsertSerial(int iSerial) 34 | { 35 | char cVal[16]; 36 | if(iSerial < 10) sprintf(cVal, "000%d", iSerial); 37 | else if(iSerial < 100) sprintf(cVal, "00%d", iSerial); 38 | else if(iSerial < 1000) sprintf(cVal, "0%d", iSerial); 39 | else sprintf(cVal, "%d", iSerial); 40 | 41 | char* pcHome = getenv("HOME"); 42 | 43 | int iSize = 128; 44 | char* pcNewName = new char[iSize]; 45 | if(m_pcMainName == NULL) 46 | { strcpy(pcNewName, pcHome); 47 | strcat(pcNewName, "/test"); 48 | } 49 | else strcpy(pcNewName, m_pcMainName); 50 | 51 | strcat(pcNewName, cVal); 52 | strcat(pcNewName, "."); 53 | if(m_pcExtName != NULL) strcat(pcNewName, m_pcExtName); 54 | return pcNewName; 55 | } 56 | 57 | char* Util_FileName::ReplaceExt(char* pcExt) 58 | { 59 | int iSize = 128; 60 | char* pcNewName = new char[iSize]; 61 | if(m_pcMainName == NULL) strcpy(pcNewName, "~/test"); 62 | else strcpy(pcNewName, m_pcMainName); 63 | if(pcExt == NULL || strlen(pcExt) == 0) return pcNewName; 64 | strcat(pcNewName, "."); 65 | strcat(pcNewName, pcExt); 66 | return pcNewName; 67 | } 68 | 69 | char* Util_FileName::AppendText(char* pcText) 70 | { 71 | int iSize = 128; 72 | char* pcNewName = new char[iSize]; 73 | strcpy(pcNewName, m_pcMainName); 74 | if(pcText != NULL && strlen(pcText) > 0) strcat(pcNewName, pcText); 75 | if(m_pcExtName == NULL) return pcNewName; 76 | strcat(pcNewName, "."); 77 | strcat(pcNewName, m_pcExtName); 78 | return pcNewName; 79 | } 80 | 81 | int Util_FileName::GetFreeDiskSpace(void) 82 | { struct statvfs aStatvfs; 83 | int iStatus = statvfs("/", &aStatvfs); 84 | if(iStatus == -1) return 0; 85 | 86 | double dTotal = aStatvfs.f_bfree * (aStatvfs.f_bsize / 1024); 87 | int iTotal = (int)(dTotal / (1024 * 1024)); 88 | return iTotal; 89 | } 90 | 91 | void Util_FileName::mSetFileName(char* pcFileName) 92 | { 93 | int iSize = 128; 94 | m_pcMainName = NULL; 95 | m_pcExtName = NULL; 96 | m_pcFileName = new char[iSize]; 97 | memset(m_pcFileName, 0, sizeof(char) * iSize); 98 | 99 | if(pcFileName == NULL || strlen(pcFileName) == 0) return; 100 | strcpy(m_pcFileName, pcFileName); 101 | char* pcNext = NULL; 102 | m_pcMainName = strtok(m_pcFileName, "."); 103 | m_pcExtName = strtok(NULL, "."); 104 | } 105 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_FileName.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_FileName 4 | { 5 | public: 6 | 7 | Util_FileName(char* pcFileName); 8 | 9 | 10 | ~Util_FileName(void); 11 | 12 | //--------------------------------------------------------------- 13 | // Extract the string before file extension. For example, if the 14 | // input file name is "/temp/test.mrc", this method returns 15 | // "/temp/test". Do not free memory of returned string. 16 | //--------------------------------------------------------------- 17 | char* GetMainName(void); /* [out] */ 18 | 19 | //--------------------------------------------------------------- 20 | // Return the file extension. Do not free memory of returned 21 | // string. 22 | //--------------------------------------------------------------- 23 | char* GetExtName(void); /* [out] */ 24 | 25 | //--------------------------------------------------------------- 26 | // Insert a serial number before file extension. For example, if 27 | // the file name is "/temp/test.mrc" and the serial number is 28 | // 10, the return is "/temp/test0010.mrc". Caller free memory. 29 | //--------------------------------------------------------------- 30 | char* InsertSerial(int iSerial); /* out */ 31 | 32 | char* ReplaceExt(char* pcExt); /* out */ 33 | 34 | //--------------------------------------------------------------- 35 | // Append the text before the file extension. For example, if the 36 | // file name is "/temp/test.mrc" and the text is "tgt", the 37 | // return is "/temp/testtgt.mrc". Caller frees memory. 38 | //--------------------------------------------------------------- 39 | char* AppendText(char* pcText); /* [out] */ 40 | 41 | //--------------------------------------------------------------- 42 | // Returns the free space in GB of the drive where the file will 43 | // be written. 44 | //--------------------------------------------------------------- 45 | int GetFreeDiskSpace(void); 46 | 47 | private: 48 | 49 | void mSetFileName(char* pcFileName); 50 | 51 | char* m_pcFileName; 52 | 53 | char* m_pcMainName; 54 | 55 | char* m_pcExtName; 56 | }; 57 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_Folder.cpp: -------------------------------------------------------------------------------- 1 | #include "Util_Folder.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | Util_Folder::Util_Folder(void) 10 | { 11 | } 12 | 13 | Util_Folder::~Util_Folder(void) 14 | { 15 | } 16 | 17 | char* Util_Folder::GetFolderPath(char* pcFullPath) 18 | { 19 | if(pcFullPath == NULL) return NULL; 20 | int iSize = strlen(pcFullPath); 21 | if(iSize == 0) return NULL; 22 | int iLastSlash = mFindLastSlash(pcFullPath); 23 | if(iLastSlash == -1) return NULL; 24 | 25 | char* pcFolderPath = new char[iLastSlash + 1]; 26 | memset(pcFolderPath, 0, sizeof(char) * (iLastSlash + 1)); 27 | memcpy(pcFolderPath, pcFullPath, sizeof(char) * iLastSlash); 28 | return pcFolderPath; 29 | } 30 | 31 | bool Util_Folder::IsValid(char* pcFolderPath) 32 | { 33 | int iFile = open(pcFolderPath, O_DIRECTORY, S_IRGRP | S_IWUSR); 34 | if(iFile == -1) return false; 35 | else return true; 36 | } 37 | 38 | void Util_Folder::Create(char* pcFolderPath) 39 | { 40 | if(pcFolderPath == NULL || strlen(pcFolderPath) == 0) return; 41 | int iNumParentFolders = mGetNumParentFolders(pcFolderPath); 42 | for(int i=0; i 4 | #include 5 | #include 6 | 7 | bool Util_Number::ParseInt(char* pcVal, int& iOutVal) 8 | { 9 | iOutVal = atoi(pcVal); 10 | if(iOutVal == 0) return Util_Number::mCheckString(pcVal); 11 | else return true; 12 | } 13 | 14 | bool Util_Number::ParseFloat(char* pcVal, float& fOutVal) 15 | { 16 | fOutVal = (float)atof(pcVal); 17 | if(fOutVal == 0.0f) return Util_Number::mCheckString(pcVal); 18 | else return true; 19 | } 20 | 21 | void Util_Number::ToString(double dNumber, char* pcStr) 22 | { 23 | if(pcStr == NULL) return; 24 | sprintf(pcStr, "%f", dNumber); 25 | } 26 | 27 | void Util_Number::ToString(int iNumber, char* pcStr) 28 | { 29 | if(pcStr == NULL) return; 30 | sprintf(pcStr, "%d", iNumber); 31 | } 32 | 33 | int Util_Number::Round(double dVal) 34 | { 35 | int iVal = (int)dVal; 36 | if((iVal - dVal) >= 0.5) return (iVal++); 37 | else if((dVal - iVal) <= -0.5) return (iVal--); 38 | else return iVal; 39 | } 40 | 41 | bool Util_Number::mCheckString(char* pcVal) 42 | { 43 | if(pcVal == NULL || strlen(pcVal) == 0) return false; 44 | return true; 45 | } 46 | 47 | bool Util_Number::mIsDigit(char c) 48 | { 49 | char cVal = c - '0'; 50 | if(cVal >= 0 && cVal <= 9) return true; 51 | else return false; 52 | } 53 | 54 | bool Util_Number::mIsSign(char c) 55 | { 56 | if(c == '+' || c == '-') return true; 57 | else return false; 58 | } 59 | 60 | bool Util_Number::mIsSpace(char c) 61 | { 62 | if(c == ' ') return true; 63 | else return false; 64 | } 65 | 66 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_Number.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //============================================================================= 4 | // 5 | // This class parses string to integer and float. 6 | // 7 | // Shawn Zheng, 01/24/2003 8 | // 9 | //============================================================================= 10 | class Util_Number 11 | { 12 | public: 13 | 14 | /* 15 | * Parse a string made of digits into a number. If the string 16 | * contains any letters except 0 to 9, +, -, and space, the 17 | * parsing fails. 18 | * 19 | * @return true if parsing success otherwise false. 20 | */ 21 | static bool ParseInt(char* pcVal, int& iOutVal); 22 | 23 | /* 24 | * Parse a string made of digits into a float number. If the 25 | * string contains any letters except 0 to 9, +, -, . and 26 | * space, the parsing fails. 27 | * 28 | * @return true if parsing success otherwise false. 29 | */ 30 | static bool ParseFloat(char* pcVal, float& fOutVal); 31 | 32 | /* 33 | * convert a real number into a string. 34 | */ 35 | static void ToString(double dNumber, char* pcStr); 36 | 37 | /* 38 | * convert a int number to a string 39 | */ 40 | static void ToString(int iNumber, char* pcStr); 41 | 42 | static int Round(double dVal); 43 | 44 | static bool mCheckString(char* pcVal); 45 | 46 | static bool mIsDigit(char c); 47 | 48 | static bool mIsSign(char c); 49 | 50 | static bool mIsSpace(char c); 51 | }; 52 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_Powell.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_Powell 4 | { 5 | public: 6 | Util_Powell(void); 7 | virtual ~Util_Powell(void); 8 | virtual float Eval(float* pfPoint); // must be overriden 9 | void Clean(void); 10 | void Setup(int iDim, int iIterations, float fTol); 11 | float DoIt 12 | ( float* pfInitPoint, 13 | float* pfSearchRange, 14 | int iNumSteps 15 | ); 16 | int m_iDim; 17 | float* m_pfInitPoint; 18 | float* m_pfBestPoint; 19 | float m_fInitVal; 20 | float m_fBestVal; 21 | private: 22 | float mDoIt(void); 23 | float mLineMinimize(float* pfPoint, float* pfVector); 24 | void mCalcNewPoint 25 | ( float* pfOldPoint, 26 | float* pfVector, 27 | float fStride, 28 | float* pfNewPoint 29 | ); 30 | void mNormVector(float* pfVector); 31 | void mFindAllowableRange 32 | ( float* pfStartPoint, 33 | float* pfVector, 34 | float* pfRange 35 | ); 36 | int m_iIterations; 37 | int m_iNumSteps; 38 | float m_fTol; 39 | float* m_pfPointMin; 40 | float* m_pfPointMax; 41 | float* m_pfVectors; 42 | float m_fTiny; 43 | }; 44 | 45 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_String.cpp: -------------------------------------------------------------------------------- 1 | #include "Util_String.h" 2 | #include 3 | #include 4 | 5 | void Util_String::RemoveSpace(char* pcString) 6 | { 7 | if(pcString == 0L || strlen(pcString) == 0) return; 8 | int iSize = strlen(pcString) + 1; 9 | char* pcBuf = new char[iSize]; 10 | strcpy(pcBuf, ""); 11 | 12 | char* pcToken = NULL; 13 | for(int i=0; i 3 | #include 4 | 5 | #define swap4(x) ( ((x >> 24) & 0xff) | ((x & 0xff0000) >> 8) \ 6 | | ((x & 0xff00) << 8) | ((x & 0xff) << 24) ) 7 | 8 | #define swap2(x) (((x & 0xffff) >> 8)|((x & 0xff) << 8)) 9 | 10 | short Util_SwapByte::DoIt(short sVal) 11 | { 12 | return swap2(sVal); 13 | } 14 | 15 | unsigned short Util_SwapByte::DoIt(unsigned short sVal) 16 | { 17 | return swap2(sVal); 18 | } 19 | 20 | int Util_SwapByte::DoIt(int iVal) 21 | { 22 | return swap4(iVal); 23 | } 24 | 25 | unsigned int Util_SwapByte::DoIt(unsigned int iVal) 26 | { 27 | return swap4(iVal); 28 | } 29 | 30 | float Util_SwapByte::DoIt(float fVal) 31 | { 32 | unsigned int* piVal = (unsigned int*)(&fVal); 33 | *piVal = swap4(*piVal); 34 | return fVal; 35 | } 36 | 37 | double Util_SwapByte::DoIt(double dVal) 38 | { 39 | int64_t* piVal = (int64_t*)(&dVal); 40 | unsigned int iLow = (unsigned int)((*piVal) & 0xffffffff); 41 | unsigned int iHigh = (unsigned int)(((*piVal) >> 32) & 0xffffffff); 42 | iLow = Util_SwapByte::DoIt(iLow); 43 | iHigh = Util_SwapByte::DoIt(iHigh); 44 | *piVal = ((int64_t)iLow << 32) + iHigh; 45 | return dVal; 46 | } 47 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_SwapByte.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | class Util_SwapByte 4 | { 5 | public: 6 | 7 | static short DoIt(short sData); 8 | 9 | static unsigned short DoIt(unsigned short sData); 10 | 11 | static int DoIt(int iData); 12 | 13 | static unsigned int DoIt(unsigned int iData); 14 | 15 | static float DoIt(float fData); 16 | 17 | static double DoIt(double dData); 18 | }; 19 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_Thread.cpp: -------------------------------------------------------------------------------- 1 | #include "Util_Thread.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | Util_Thread::Util_Thread(void) 8 | { 9 | m_bCreated = false; 10 | pthread_mutex_init(&m_aMutex, NULL); 11 | pthread_cond_init(&m_aCond, NULL); 12 | } 13 | 14 | Util_Thread::~Util_Thread() 15 | { 16 | pthread_mutex_destroy(&m_aMutex); 17 | pthread_cond_destroy(&m_aCond); 18 | } 19 | 20 | void Util_Thread::Start(void) 21 | { 22 | m_bStop = false; 23 | int iStatus = pthread_create(&m_aThread, NULL, 24 | Util_Thread::ThreadFunc, (void*)this); 25 | if(iStatus == 0) m_bCreated = true; 26 | else m_bCreated = false; 27 | } 28 | 29 | void Util_Thread::Stop(void) 30 | { 31 | if(!m_bCreated) return; 32 | m_bStop = true; 33 | } 34 | 35 | bool Util_Thread::IsAlive(void) 36 | { 37 | if(!m_bCreated) return false; 38 | //--------------------------- 39 | void* pvRet = 0L; 40 | int iStatus = pthread_tryjoin_np(m_aThread, &pvRet); 41 | if(iStatus == EBUSY) return true; 42 | else if(iStatus == ETIMEDOUT) return true; 43 | //---------------------------------------- 44 | m_bCreated = false; 45 | return false; 46 | } 47 | 48 | bool Util_Thread::IsCreated(void) 49 | { 50 | return m_bCreated; 51 | } 52 | 53 | bool Util_Thread::WaitForExit(float fSeconds) 54 | { 55 | if(!m_bCreated) return true; 56 | //-------------------------- 57 | if(fSeconds < 0) 58 | { pthread_join(m_aThread, NULL); 59 | m_bCreated = false; 60 | return true; 61 | } 62 | //------------------ 63 | int iSeconds = (int)fSeconds; 64 | struct timespec ts; 65 | clock_gettime(CLOCK_REALTIME, &ts); 66 | ts.tv_sec += iSeconds; 67 | ts.tv_nsec += (int)((fSeconds - iSeconds) * 1e9); 68 | int iRet = pthread_timedjoin_np(m_aThread, NULL, &ts); 69 | //---------------------------------------------------- 70 | if(iRet != 0) return false; 71 | m_bCreated = false; 72 | return true; 73 | /* 74 | else if(iRet == ETIMEDOUT) return false; 75 | else if(iRet == EBUSY) return false; 76 | //---------------------------------- 77 | printf("Util_Thread::WaitForExit: iRet = %d\n", iRet); 78 | m_bCreated = false; 79 | return true; 80 | */ 81 | } 82 | 83 | bool Util_Thread::WaitSeconds(float fSeconds) 84 | { 85 | return mWait(fSeconds); 86 | } 87 | 88 | void Util_Thread::ThreadMain(void) 89 | { 90 | } 91 | 92 | bool Util_Thread::mWait(float fSeconds) 93 | { 94 | int iSeconds = (int)fSeconds; 95 | int iUSeconds = (int)((fSeconds - iSeconds) * 1e6); 96 | //------------------------------------------------- 97 | struct timespec ts; 98 | clock_gettime(CLOCK_REALTIME, &ts); 99 | ts.tv_sec += iSeconds; 100 | ts.tv_nsec += iUSeconds * 1000; 101 | //----------------------------- 102 | pthread_mutex_lock(&m_aMutex); 103 | int iStatus = pthread_cond_timedwait(&m_aCond, &m_aMutex, &ts); 104 | pthread_mutex_unlock(&m_aMutex); 105 | //------------------------------ 106 | if(iStatus == ETIMEDOUT) return false; 107 | else return true; 108 | } 109 | 110 | void* Util_Thread::ThreadFunc(void* pParam) 111 | { 112 | Util_Thread* pThread = (Util_Thread*)pParam; 113 | pThread->ThreadMain(); 114 | return 0L; 115 | } 116 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_Thread.h: -------------------------------------------------------------------------------- 1 | //============================================================================= 2 | // 3 | // On Linux, you must compile with the -D_REENTRANT option. This tells 4 | // the C/C++ libraries that the functions must be thread-safe 5 | // 6 | //============================================================================= 7 | #pragma once 8 | #include 9 | 10 | class Util_Thread 11 | { 12 | public: 13 | 14 | Util_Thread(void); 15 | virtual ~Util_Thread(); 16 | virtual void ThreadMain(void); 17 | void Start(void); 18 | void Stop(void); 19 | bool WaitForExit(float fSeconds); 20 | bool WaitSeconds(float fSeconds); 21 | bool IsAlive(void); 22 | bool IsCreated(void); 23 | private: 24 | static void* ThreadFunc(void* pvParam); 25 | protected: 26 | bool mWait(float fSeconds); 27 | pthread_t m_aThread; 28 | pthread_cond_t m_aCond; 29 | pthread_mutex_t m_aMutex; 30 | bool m_bCreated; 31 | bool m_bStop; 32 | }; 33 | 34 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_Time.cpp: -------------------------------------------------------------------------------- 1 | #include "Util_Time.h" 2 | #include 3 | #include 4 | 5 | void Util_Time::Measure(void) 6 | { 7 | gettimeofday(&m_aTimeval, NULL); 8 | } 9 | 10 | float Util_Time::GetElapsedSeconds(void) 11 | { 12 | struct timeval tp; 13 | gettimeofday(&tp, NULL); 14 | double dSeconds = tp.tv_sec - m_aTimeval.tv_sec 15 | + (tp.tv_usec - m_aTimeval.tv_usec) * 1e-6; 16 | return (float)dSeconds; 17 | } 18 | -------------------------------------------------------------------------------- /LibSrc/Util/Util_Time.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include 4 | 5 | class Util_Time 6 | { 7 | public: 8 | 9 | void Measure(void); 10 | 11 | float GetElapsedSeconds(void); 12 | 13 | private: 14 | 15 | struct timeval m_aTimeval; 16 | 17 | }; 18 | 19 | -------------------------------------------------------------------------------- /LibSrc/Util/makefile: -------------------------------------------------------------------------------- 1 | PROJ_DIR = $(shell pwd)/.. 2 | SRCS = $(wildcard *.cpp) 3 | HDRS = $(patsubst %.cpp, %.h, $(SRCS)) 4 | OBJS = $(patsubst %.cpp, %.o, $(SRCS)) 5 | #------------------- 6 | OUT = libutil.a 7 | 8 | CC = g++ -std=c++11 9 | CFLAG = -c -g -pthread -m64 10 | 11 | all: $(OBJS) 12 | @echo create library $(OUT) and move to $(PROJ_DIR)/Lib 13 | @echo copy headers to $(PROJ_DIR)/Include/Util 14 | @ar rcs $(OUT) $(OBJS) 15 | @mv $(OUT) $(PROJ_DIR)/Lib 16 | @cp $(HDRS) $(PROJ_DIR)/Include/Util 17 | 18 | %.o: %.cpp 19 | $(CC) $(CFLAG) $< -o $@ 20 | 21 | list: 22 | @echo $(OBJS) 23 | 24 | clean: 25 | @echo delete all object files and temporary files 26 | @rm -f $(OBJS) 27 | @rm -f $(PROJ_DIR)/Util/*.*~ 28 | @rm -f $(PROJ_DIR)/Util/*~ 29 | -------------------------------------------------------------------------------- /MotionDecon/CMotionDeconInc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include "../Util/CUtilInc.h" 3 | #include "../MrcUtil/CMrcUtilInc.h" 4 | #include "../Align/CAlignInc.h" 5 | #include 6 | #include 7 | 8 | namespace MotionCor2 9 | { 10 | namespace MotionDecon 11 | { 12 | 13 | class GDeconFrame 14 | { 15 | public: 16 | GDeconFrame(void); 17 | ~GDeconFrame(void); 18 | void CleanGpu(void); 19 | void CalcSinc2Sum 20 | ( float* pfInFrmShifts, 21 | int iNumFrames, 22 | int* piCmpSize 23 | ); 24 | void DirWeightFrame 25 | ( int iFrame, 26 | cufftComplex* pCmpFrm, 27 | bool bGpu 28 | ); 29 | void WeightFrame 30 | ( float fShift, 31 | cufftComplex* pCmpFrm, 32 | bool bGpu, 33 | int* piCmpSize 34 | ); 35 | int m_aiCmpSize[2]; 36 | int m_iNumFrames; 37 | private: 38 | cufftComplex* mH2D 39 | ( cufftComplex* pCmpFrm, 40 | bool bGpu, 41 | int* piCmpSize 42 | ); 43 | void mD2H 44 | ( cufftComplex* gCmpFrm, 45 | cufftComplex* pCmpFrm, 46 | bool bGpu, 47 | int* piCmpSize 48 | ); 49 | float* m_gfSinc2Sum; 50 | float* m_pfInFrmShifts; 51 | }; 52 | 53 | class GMotionWeight 54 | { 55 | public: 56 | GMotionWeight(void); 57 | ~GMotionWeight(void); 58 | void DirWeight 59 | ( float* pfMotion, 60 | cufftComplex* pCmpFrm, 61 | int* piCmpSize, 62 | cudaStream_t stream=0 63 | ); 64 | void Weight 65 | ( float fMotion, 66 | cufftComplex* pCmpFrm, 67 | int* piCmpSize, 68 | cudaStream_t stream=0 69 | ); 70 | }; 71 | 72 | class CInFrameMotion 73 | { 74 | public: 75 | CInFrameMotion(void); 76 | ~CInFrameMotion(void); 77 | void SetFullShift(Align::CStackShift* pStackShift); 78 | void SetPatchShifts(Align::CPatchShifts* pPatchShifts); 79 | void DoFullMotion 80 | ( int iFrame, 81 | cufftComplex* pCmpFrm, 82 | int* piCmpSize, 83 | cudaStream_t stream=0 84 | ); 85 | void DoLocalMotion 86 | ( int iFrame, 87 | cufftComplex* pCmpFrm, 88 | int* piCmpSize, 89 | cudaStream_t stream=0 90 | ); 91 | void GetFullMotion 92 | ( int iFrame, 93 | float* pfMotion // 2 elements 94 | ); 95 | void GetLocalMotion 96 | ( int iFrame, 97 | int iPatch, 98 | float* pfMotion // 2 elements 99 | ); 100 | int m_iNumFrames; 101 | int m_iNumPatches; 102 | private: 103 | void mCalculate(Align::CStackShift* pStackShift); 104 | Align::CStackShift* m_pFullShift; 105 | Align::CPatchShifts* m_pPatchShifts; 106 | }; 107 | 108 | 109 | } 110 | } 111 | 112 | -------------------------------------------------------------------------------- /MrcUtil/CAnalyzeMrc.cpp: -------------------------------------------------------------------------------- 1 | #include "CMrcUtilInc.h" 2 | #include "../CMainInc.h" 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace MotionCor2::MrcUtil; 10 | 11 | CAnalyzeMrc::CAnalyzeMrc(void) 12 | { 13 | } 14 | 15 | CAnalyzeMrc::~CAnalyzeMrc(void) 16 | { 17 | } 18 | 19 | bool CAnalyzeMrc::IsMrc(char* pcMrcFile) 20 | { 21 | Mrc::CLoadMrc aLoadMrc; 22 | bool bOpen = aLoadMrc.OpenFile(pcMrcFile); 23 | if(!bOpen) return false; 24 | else return true; 25 | } 26 | 27 | bool CAnalyzeMrc::IsTomoMrc(char* pcMrcFile) 28 | { 29 | Mrc::CLoadMrc aLoadMrc; 30 | if(!aLoadMrc.OpenFile(pcMrcFile)) return false; 31 | int iNumFloats = aLoadMrc.m_pLoadMain->GetNumFloats(); 32 | if(iNumFloats == 0) return false; 33 | //------------------------------- 34 | int iNumImgs = aLoadMrc.m_pLoadMain->GetSizeZ(); 35 | float afTilt[] = {0.0f, 0.0f}; 36 | aLoadMrc.m_pLoadExt->DoIt(0); 37 | aLoadMrc.m_pLoadExt->GetTilt(afTilt+0, 1); 38 | aLoadMrc.m_pLoadExt->DoIt(iNumImgs-1); 39 | aLoadMrc.m_pLoadExt->GetTilt(afTilt+1, 1); 40 | //---------------------------------------- 41 | float fRange = fabs(afTilt[0] - afTilt[1]); 42 | if(fabs(afTilt[0]) > 80) return false; 43 | else if(fabs(afTilt[1]) > 80) return false; 44 | else if(fRange <= 2) return false; 45 | else return true; 46 | } 47 | 48 | bool CAnalyzeMrc::IsSerialTomoMrc(char* pcMrcFile) 49 | { 50 | Mrc::CLoadMrc aLoadMrc; 51 | bool bOpen = aLoadMrc.OpenFile(pcMrcFile); 52 | if(!bOpen) return false; 53 | //---------------------- 54 | int iNumFloats = aLoadMrc.m_pLoadMain->GetNumFloats(); 55 | if(iNumFloats <= 0) return false; 56 | //------------------------------- 57 | int iSizeZ = aLoadMrc.m_pLoadMain->GetSizeZ(); 58 | char acSerialFile[256]; 59 | for(int i=0; iGetSizeX(); 81 | piMrcSize[1] = aLoadMrc.m_pLoadMain->GetSizeY(); 82 | piMrcSize[2] = aLoadMrc.m_pLoadMain->GetSizeZ(); 83 | //------------------------------------------- 84 | int iStackZ = aLoadMrc.m_pLoadMain->GetStackZ(); 85 | if(iStackZ > 0) *piNumStacks = piMrcSize[2] / iStackZ; 86 | } 87 | -------------------------------------------------------------------------------- /MrcUtil/CAsyncSingleSave.cpp: -------------------------------------------------------------------------------- 1 | #include "CMrcUtilInc.h" 2 | #include 3 | #include 4 | 5 | using namespace MotionCor2::MrcUtil; 6 | 7 | CAsyncSingleSave::CAsyncSingleSave(void) 8 | { 9 | memset(m_acMrcFile, 0, sizeof(m_acMrcFile)); 10 | m_pfImg = 0L; 11 | } 12 | 13 | CAsyncSingleSave::~CAsyncSingleSave(void) 14 | { 15 | if(m_pfImg != 0L) delete[] m_pfImg; 16 | m_pfImg = 0L; 17 | } 18 | 19 | void CAsyncSingleSave::DoIt 20 | ( char* pcMrcFile, 21 | float* pfImg, 22 | int* piImgSize, 23 | float fPixelSize, 24 | bool bClean, 25 | bool bAsync 26 | ) 27 | { strcpy(m_acMrcFile, pcMrcFile); 28 | memcpy(m_aiImgSize, piImgSize, sizeof(m_aiImgSize)); 29 | //-------------------------------------------------- 30 | m_pfImg = pfImg; 31 | m_fPixelSize = fPixelSize; 32 | m_bClean = bClean; 33 | if(bAsync) Util_Thread::Start(); 34 | else mSave(); 35 | } 36 | 37 | void CAsyncSingleSave::ThreadMain(void) 38 | { 39 | mSave(); 40 | } 41 | 42 | void CAsyncSingleSave::mSave(void) 43 | { 44 | if(m_pfImg == 0L) return; 45 | //----------------------- 46 | Mrc::CSaveMrc aSaveMrc; 47 | if(!aSaveMrc.OpenFile(m_acMrcFile)) 48 | { if(m_bClean) delete[] m_pfImg; 49 | m_pfImg = 0L; 50 | return; 51 | } 52 | //------------- 53 | aSaveMrc.SetMode(Mrc::eMrcFloat); 54 | aSaveMrc.SetImgSize(m_aiImgSize, 1, 1, m_fPixelSize); 55 | aSaveMrc.SetExtHeader(0, 0, 0); 56 | aSaveMrc.DoIt(0, m_pfImg); 57 | //-------------------------- 58 | if(m_bClean) delete[] m_pfImg; 59 | m_pfImg = 0L; 60 | } 61 | 62 | -------------------------------------------------------------------------------- /MrcUtil/CTiltAngles.cpp: -------------------------------------------------------------------------------- 1 | #include "CMrcUtilInc.h" 2 | #include "../CMainInc.h" 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace MotionCor2::MrcUtil; 10 | 11 | CTiltAngles::CTiltAngles(void) 12 | { 13 | m_fStartTilt = 0.0f; 14 | m_fTiltStep = 2.0f; 15 | m_iNumTilts = 0; 16 | } 17 | 18 | CTiltAngles::~CTiltAngles(void) 19 | { 20 | } 21 | 22 | void CTiltAngles::Setup 23 | ( float fFirstTilt, 24 | float fTiltStep 25 | ) 26 | { m_fStartTilt = fFirstTilt; 27 | m_fTiltStep = fTiltStep; 28 | } 29 | 30 | bool CTiltAngles::Read(char* pcMrcFile) 31 | { 32 | m_fMaxTilt = -180.0f; 33 | m_fMinTilt = 180.0f; 34 | m_iNumTilts = 0; 35 | if(fabs(m_fTiltStep) <= 0.1) return false; 36 | //---------------------------------------- 37 | Mrc::CLoadMrc aLoadMrc; 38 | if(!aLoadMrc.OpenFile(pcMrcFile)) return false; 39 | //--------------------------------------------- 40 | int iSizeZ = aLoadMrc.m_pLoadMain->GetSizeZ(); 41 | int iStackZ = aLoadMrc.m_pLoadMain->GetStackZ(); 42 | if(iStackZ < 1) iStackZ = 1; 43 | else if(iStackZ >= iSizeZ) iStackZ = 1; 44 | //------------------------------------- 45 | float fTilt = 0.0f; 46 | int iNumStarts = 0; 47 | //----------------- 48 | for(int i=0; iDoIt(i); 50 | aLoadMrc.m_pLoadExt->GetTilt(&fTilt, 1); 51 | //-------------------------------------- 52 | if(fTilt > m_fMaxTilt) m_fMaxTilt = fTilt; 53 | else if(fTilt < m_fMinTilt) m_fMinTilt = fTilt; 54 | //--------------------------------------------- 55 | if(fabs(fTilt - m_fStartTilt) >= 0.2) continue; 56 | else iNumStarts += 1; 57 | } 58 | //--------------------------- 59 | float fNumTilts = (m_fMaxTilt - m_fMinTilt) / m_fTiltStep; 60 | m_iNumTilts = (int)(fabs(fNumTilts) + 0.5f) + 1; 61 | if(iNumStarts == 2) m_iNumTilts += 1; 62 | //----------------------------------- 63 | float fEndTilt1 = (m_fTiltStep > 0) ? m_fMaxTilt : m_fMinTilt; 64 | float fHalf1 = (fEndTilt1 - m_fStartTilt) / m_fTiltStep; 65 | m_iHalf1 = (int)(fHalf1 + 0.5f) + 1; 66 | return true; 67 | } 68 | 69 | int CTiltAngles::GetAcqIndex(float fTilt, float* pfShift) 70 | { 71 | if(m_iNumTilts <= 0) return 0; 72 | //---------------------------- 73 | double dShift = 0; 74 | if(pfShift != 0L) dShift = fabs(pfShift[0]) + fabs(pfShift[1]); 75 | //------------------------------------------------------------- 76 | int iSign = (m_fTiltStep > 0) ? 1 : -1; 77 | float fIndex = (fTilt - m_fStartTilt) / m_fTiltStep; 78 | int iIndex = (int)(fIndex + iSign * 0.5f); 79 | //---------------------------------------- 80 | if(iIndex == 0 && dShift == 0) return 0; 81 | else if(iIndex > 0) return iIndex; 82 | else return m_iHalf1 - iIndex; 83 | 84 | } 85 | 86 | -------------------------------------------------------------------------------- /MrcUtil/G4BitImage.cu: -------------------------------------------------------------------------------- 1 | #include "CMrcUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::MrcUtil; 8 | 9 | static __global__ void mGPack 10 | ( unsigned char* pucRawFrm, 11 | unsigned char* pucPkdFrm, 12 | int iSizeX, 13 | int iSizeY, 14 | int iPackX 15 | ) 16 | { int y = blockIdx.y * blockDim.y + threadIdx.y; 17 | if(y >= iSizeY) return; 18 | //--------------------- 19 | int x2 = blockIdx.x * 2; 20 | int i = y * iPackX + blockIdx.x; 21 | int j = y * iSizeX + x2; 22 | //---------------------- 23 | pucPkdFrm[i] = pucRawFrm[j] & 0xf; 24 | if((x2+1) >= iSizeX) return; 25 | pucPkdFrm[i] += ((pucRawFrm[j+1] & 0xf) << 4); 26 | } 27 | 28 | static __global__ void mGUnpack 29 | ( unsigned char* gucPkdFrm, 30 | unsigned char* gucRawFrm, 31 | int iPackX, 32 | int iSizeX 33 | ) 34 | { int x = blockIdx.x * blockDim.x + threadIdx.x; 35 | if(x >= iSizeX) return; 36 | int i = blockIdx.y * iSizeX + x; 37 | int j = blockIdx.y * iPackX + x / 2; 38 | if((x % 2) == 0) gucRawFrm[i] = gucPkdFrm[j] & 0xf; 39 | else gucRawFrm[i] = (gucPkdFrm[j] >> 4) & 0xf; 40 | } 41 | 42 | G4BitImage::G4BitImage(void) 43 | { 44 | } 45 | 46 | G4BitImage::~G4BitImage(void) 47 | { 48 | } 49 | 50 | int G4BitImage::GetPkdSize(int iSize) 51 | { 52 | return (iSize + 1) / 2; 53 | } 54 | 55 | void G4BitImage::GetPkdImgSize(int* piRawSize, int* piPkdSize) 56 | { 57 | piPkdSize[0] = G4BitImage::GetPkdSize(piRawSize[0]); 58 | piPkdSize[1] = piRawSize[1]; 59 | } 60 | 61 | void G4BitImage::Pack 62 | ( unsigned char* gucRawFrm, 63 | unsigned char* gucPkdFrm, 64 | int* piRawSize 65 | ) 66 | { int iPackX = G4BitImage::GetPkdSize(piRawSize[0]); 67 | dim3 aBlockDim(1, 128); 68 | dim3 aGridDim(iPackX, 1); 69 | aGridDim.y = (piRawSize[1] + aBlockDim.y - 1) / aBlockDim.y; 70 | mGPack<<>>(gucRawFrm, gucPkdFrm, 71 | piRawSize[0], piRawSize[1], iPackX); 72 | } 73 | 74 | void G4BitImage::Unpack 75 | ( unsigned char* gucPkdFrm, 76 | unsigned char* gucRawFrm, 77 | int* piRawSize 78 | ) 79 | { dim3 aBlockDim(128, 1); 80 | dim3 aGridDim(1, piRawSize[1]); 81 | aGridDim.x = (piRawSize[0] + aBlockDim.x - 1) / aBlockDim.x; 82 | int iPackX = G4BitImage::GetPkdSize(piRawSize[0]); 83 | mGUnpack<<>>(gucPkdFrm, gucRawFrm, 84 | iPackX, piRawSize[0]); 85 | } 86 | 87 | -------------------------------------------------------------------------------- /MrcUtil/GAugmentRef.cu: -------------------------------------------------------------------------------- 1 | #include "CMrcUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::MrcUtil; 8 | 9 | //------------------------------------------------------------------- 10 | // 1. Flip image upside down around x (horizontal) axis. 11 | //------------------------------------------------------------------- 12 | static __global__ void mGAugment 13 | ( float* gfInRef, 14 | int iInSizeX, 15 | int iFact, 16 | float* gfOutRef, 17 | int iOutSizeX, 18 | unsigned int iOutSize 19 | ) 20 | { unsigned int i = blockIdx.x * blockDim.x + threadIdx.x; 21 | if(i >= iOutSize) return; 22 | //----------------------- 23 | unsigned int y = (i / iOutSizeX) / iFact; 24 | unsigned int j = y * iInSizeX + (i % iOutSizeX) / iFact; 25 | gfOutRef[i] = gfInRef[j]; 26 | } 27 | 28 | GAugmentRef::GAugmentRef(void) 29 | { 30 | } 31 | 32 | GAugmentRef::~GAugmentRef(void) 33 | { 34 | } 35 | 36 | void GAugmentRef::DoIt 37 | ( float* gfInRef, 38 | int* piInSize, 39 | float* gfOutRef, 40 | int* piOutSize 41 | ) 42 | { int iFact = piOutSize[0] / piInSize[0]; 43 | unsigned int iOutSize = piOutSize[0] * piOutSize[1]; 44 | dim3 aBlockDim(512, 1); 45 | dim3 aGridDim((iOutSize + aBlockDim.x - 1) / aBlockDim.x, 1); 46 | mGAugment<<>>(gfInRef, piInSize[0], iFact, 47 | gfOutRef, piOutSize[0], iOutSize); 48 | } 49 | 50 | -------------------------------------------------------------------------------- /MrcUtil/GFlip2D.cu: -------------------------------------------------------------------------------- 1 | #include "CMrcUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::MrcUtil; 8 | 9 | //------------------------------------------------------------------- 10 | // 1. Flip image upside down around x (horizontal) axis. 11 | //------------------------------------------------------------------- 12 | static __global__ void mGVertical 13 | ( float* gfImg, 14 | int iSizeX, 15 | int iSizeY 16 | ) 17 | { int x = blockIdx.x * blockDim.x + threadIdx.x; 18 | if(x >= iSizeX) return; 19 | int i = blockIdx.y * iSizeX + x; 20 | //------------------------------ 21 | int iY = iSizeY - 1 - blockIdx.y; 22 | int j = iY * iSizeX + x; 23 | float fTemp = gfImg[i]; 24 | gfImg[i] = gfImg[j]; 25 | gfImg[j] = fTemp; 26 | } 27 | 28 | static __global__ void mGHorizontal 29 | ( float* gfImg, 30 | int iSizeX, 31 | int iSizeY 32 | ) 33 | { int y = blockIdx.y * blockDim.y + threadIdx.y; 34 | if(y > iSizeY) return; 35 | int i = y * iSizeX + blockIdx.x; 36 | //------------------------------ 37 | int iX = iSizeX - 1 - blockIdx.x; 38 | int j = y * iSizeX + iX; 39 | float fTemp = gfImg[i]; 40 | gfImg[i] = gfImg[j]; 41 | gfImg[j] = fTemp; 42 | } 43 | 44 | GFlip2D::GFlip2D(void) 45 | { 46 | } 47 | 48 | GFlip2D::~GFlip2D(void) 49 | { 50 | } 51 | 52 | void GFlip2D::Vertical 53 | ( float* pfImg, 54 | bool bGpu, 55 | int* piImgSize 56 | ) 57 | { if(bGpu) 58 | { mVertical(pfImg, piImgSize); 59 | return; 60 | } 61 | //------------- 62 | float* gfImg = mCopyToDevice(pfImg, piImgSize); 63 | mVertical(gfImg, piImgSize); 64 | //-------------------------- 65 | size_t tBytes = piImgSize[0] * piImgSize[1] * sizeof(float); 66 | cudaMemcpy(pfImg, gfImg, tBytes, cudaMemcpyDeviceToHost); 67 | if(gfImg != 0L) cudaFree(gfImg); 68 | } 69 | 70 | void GFlip2D::Horizontal 71 | ( float* pfImg, 72 | bool bGpu, 73 | int* piImgSize 74 | ) 75 | { if(bGpu) 76 | { mHorizontal(pfImg, piImgSize); 77 | return; 78 | } 79 | //------------- 80 | float* gfImg = mCopyToDevice(pfImg, piImgSize); 81 | mHorizontal(gfImg, piImgSize); 82 | //---------------------------- 83 | size_t tBytes = piImgSize[0] * piImgSize[1] * sizeof(float); 84 | cudaMemcpy(pfImg, gfImg, tBytes, cudaMemcpyDeviceToHost); 85 | if(gfImg != 0L) cudaFree(gfImg); 86 | } 87 | 88 | float* GFlip2D::mCopyToDevice(float* pfImg, int* piImgSize) 89 | { 90 | float* gfImg = 0L; 91 | size_t tBytes = piImgSize[0] * piImgSize[1] * sizeof(float); 92 | cudaMalloc(&gfImg, tBytes); 93 | cudaMemcpy(gfImg, pfImg, tBytes, cudaMemcpyHostToDevice); 94 | return gfImg; 95 | } 96 | 97 | void GFlip2D::mVertical 98 | ( float* gfImg, 99 | int* piImgSize 100 | ) 101 | { int iHalfY = piImgSize[1] / 2; 102 | dim3 aBlockDim(512, 1); 103 | dim3 aGridDim(1, iHalfY); 104 | aGridDim.x = piImgSize[0] / aBlockDim.x + 1; 105 | mGVertical<<>> 106 | ( gfImg, piImgSize[0], piImgSize[1] 107 | ); 108 | } 109 | 110 | void GFlip2D::mHorizontal 111 | ( float* gfImg, 112 | int* piImgSize 113 | ) 114 | { int iHalfX = piImgSize[0] / 2; 115 | dim3 aBlockDim(1, 512); 116 | dim3 aGridDim(iHalfX, 1); 117 | aGridDim.y = piImgSize[1] / aBlockDim.y + 1; 118 | mGHorizontal<<>> 119 | ( gfImg, piImgSize[0], piImgSize[1] 120 | ); 121 | } 122 | 123 | -------------------------------------------------------------------------------- /MrcUtil/GInverse2D.cu: -------------------------------------------------------------------------------- 1 | #include "CMrcUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::MrcUtil; 8 | 9 | //------------------------------------------------------------------- 10 | // 1. Inverse each pixel value. If the value is zero, it is set to 11 | // zero. This is for EER reciprocal gain. 12 | //------------------------------------------------------------------- 13 | static __global__ void mGInverse(float* gfImg, int iSizeX) 14 | { 15 | int x = blockIdx.x * blockDim.x + threadIdx.x; 16 | if(x >= iSizeX) return; 17 | int i = blockIdx.y * iSizeX + x; 18 | //------------------------------ 19 | float fTemp = gfImg[i]; 20 | if(fTemp == 0) gfImg[i] = 0.0f; 21 | else gfImg[i] = 1.0f / fTemp; 22 | } 23 | 24 | GInverse2D::GInverse2D(void) 25 | { 26 | } 27 | 28 | GInverse2D::~GInverse2D(void) 29 | { 30 | } 31 | 32 | void GInverse2D::DoIt 33 | ( float* pfImg, 34 | bool bGpu, 35 | int* piImgSize 36 | ) 37 | { if(bGpu) 38 | { mInverse(pfImg, piImgSize); 39 | return; 40 | } 41 | //------------- 42 | float* gfImg = 0L; 43 | size_t tBytes = sizeof(float) * piImgSize[0] * piImgSize[1]; 44 | cudaMalloc(&gfImg, tBytes); 45 | cudaMemcpy(gfImg, gfImg, tBytes, cudaMemcpyDefault); 46 | //-------------------------------------------------- 47 | mInverse(gfImg, piImgSize); 48 | //-------------------------- 49 | cudaMemcpy(pfImg, gfImg, tBytes, cudaMemcpyDefault); 50 | cudaFree(gfImg); 51 | } 52 | 53 | void GInverse2D::mInverse 54 | ( float* gfImg, 55 | int* piImgSize 56 | ) 57 | { dim3 aBlockDim(512, 1); 58 | dim3 aGridDim(1, piImgSize[1]); 59 | aGridDim.x = (piImgSize[0] + aBlockDim.x - 1) / aBlockDim.x; 60 | mGInverse<<>>(gfImg, piImgSize[0]); 61 | } 62 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # MotionCor3 2 | Anisotropic correction of beam induced motion for cryo-electron microscopy and cryo-electron tomography images. 3 | 4 | MotionCor3, an improved implementation of MotionCor2 with addition of CTF (Contrast Transfer Function) estimation, is a multi-GPU accelerated software package that enables single-pixel level correction of anisotropic beam induced sample motion for cryo-electron microscopy and cryo-electron tomography images. The iterative, patch-based motion detection combined with spatial and temporal constraints and dose weighting provides robust and accurate correction. By refining the measurement of early motion, MotionCor3 further improves correction on tilted samples. The efficiency achieved by multi-GPU acceleration and parallelization enables correction to keep pace with automated data collection. The recent addition of a very robust GPU-accelerated CTF estimation makes MotionCor3 more versatile in cryoEM and cryoET processing pipeline. 5 | ![ReadmeImg](https://github.com/czimaginginstitute/MotionCor3/blob/main/docs/ReadmeImg.png) 6 | 7 | (**a**) Global motion in the direction perpendicular to the tilt axis (**b**) Residual local motion measured on a micrograph acquired at 0° (**c**) Residual local motion measured on a micrograph acquired at 30° (**d**) Residual local motion measured on a micrograph acquired at 60°. 8 | 9 | 10 | ## Installation 11 | 12 | MotionCor3 is developed on Linux platform equipped with at least one Nvidia GPU card. To compile from the source, follow the steps below: 13 | 14 | 1. git clone https://github.com/czimaginginstitute/MotionCor3.git 15 | 2. cd MotionCor3 16 | 3. make exe -f makefile11 [CUDAHOME=path/cuda-xx.x] 17 | 18 | If the compute capability of GPUs is 5.x, use make instead of makefile11. If CUDAHOME is not provided, the default installation path of CUDA in makefile or makefile11 will be used. 19 | 20 | ## Code of Conduct 21 | 22 | This project adheres to the Contributor Covenant [code of conduct](https://github.com/chanzuckerberg/.github/blob/master/CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to [opensource@chanzuckerberg.com](mailto:opensource@chanzuckerberg.com). 23 | 24 | ## Reporting Security Issues 25 | 26 | If you believe you have found a security issue, please responsibly disclose by contacting us at [security@chanzuckerberg.com](mailto:security@chanzuckerberg.com). 27 | -------------------------------------------------------------------------------- /SECURITY.md: -------------------------------------------------------------------------------- 1 | ## Reporting Security Issues 2 | 3 | If you believe you have found a security issue, please responsibly disclose by contacting us at [security@chanzuckerberg.com](mailto:security@chanzuckerberg.com). 4 | -------------------------------------------------------------------------------- /TestReadme.txt: -------------------------------------------------------------------------------- 1 | Test Cases: 2 | 3 | 1. Dose weighting + mag correction, 4 | 1) 1 GPU and 2 GPU 5 | 2) -GpuMemUsage: 0.1 0.3 0.5 0.7 0.9 6 | 7 | 2. Defect correction 8 | 9 | 3. -InFmMotion 1 10 | 11 | 4. Fractional binning 1.5 12 | 13 | 5. Generate motion-corrected stack 14 | 15 | 6. Check DW, DWS files 16 | 17 | 7. Global alignment only 18 | 19 | 8. Simple sum 20 | 21 | 9. Serial Processing on 1 GPU and 2 GPUs 22 | 1) MRC input 23 | 2) TIFF input 24 | 25 | 10. Movies containing 200 K3 frames 26 | 27 | 11. Falcon Data 28 | 29 | -------------------------------------------------------------------------------- /TiffUtil/CTiffFileInc.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | #include 3 | #include "../MrcUtil/CMrcUtilInc.h" 4 | 5 | namespace MotionCor2 6 | { 7 | namespace TiffUtil 8 | { 9 | class CLoadTiffHeader 10 | { 11 | public: 12 | CLoadTiffHeader(void); 13 | ~CLoadTiffHeader(void); 14 | bool DoIt(int iFile); 15 | int GetSizeX(void); 16 | int GetSizeY(void); 17 | int GetSizeZ(void); 18 | void GetSize(int* piSize, int iElems); 19 | int GetMode(void); 20 | float GetPixelSize(void); 21 | int GetTileSizeX(void); 22 | int GetTileSizeY(void); 23 | int GetNumTilesX(void); 24 | int GetNumTilesY(void); 25 | bool IsStrip(void); // Read rows per strip 26 | bool IsTile(void); // Read tiles 27 | private: 28 | bool mReadImageSize(void); 29 | bool mReadMode(void); 30 | void mReadPixelSize(void); 31 | bool mReadRowsPerStrip(void); 32 | bool mReadTileSize(void); 33 | int m_aiImgSize[3]; 34 | int m_iMode; 35 | float m_fPixelSize; 36 | int m_aiTileSize[2]; 37 | int m_aiNumTiles[2]; 38 | bool m_bReadImgSize; 39 | bool m_bReadMode; 40 | bool m_bRowsPerStrip; 41 | bool m_bTileSize; 42 | TIFF* m_pTiff; 43 | }; 44 | 45 | class CLoadTiffImage 46 | { 47 | public: 48 | CLoadTiffImage(void); 49 | ~CLoadTiffImage(void); 50 | bool SetFile(int iFile); 51 | void* DoIt(int iNthImage); 52 | bool DoIt(int iNthImage, void* pvImage); 53 | int m_iMode; 54 | int m_aiSize[3]; 55 | private: 56 | bool mReadByStrip(int iNthImage, void* pvImage); 57 | bool mReadByTile(int iNthImage, void* pvImage); 58 | TIFF* m_pTiff; 59 | CLoadTiffHeader m_aLoadHeader; 60 | int m_iPixelBytes, m_iImgBytes; 61 | }; 62 | 63 | class CLoadTiffStack : public Util_Thread 64 | { 65 | public: 66 | CLoadTiffStack(void); 67 | ~CLoadTiffStack(void); 68 | static void Clean(void); 69 | static bool OpenFile(int aiStkSize[3]); 70 | static void AsyncLoad(void); 71 | static void* GetPackage(void); 72 | void Run(int iFile); 73 | void ThreadMain(void); 74 | private: 75 | void mLoadSingle(void); 76 | void mLoadIntGpu(void); 77 | void mLoadIntCpu(void); 78 | int m_iFile; 79 | CLoadTiffImage* m_pLoadTiffImage; 80 | bool m_bLoaded; 81 | float m_fLoadTime; 82 | }; 83 | 84 | class CTiffFolder 85 | { 86 | public: 87 | CTiffFolder(void); 88 | ~CTiffFolder(void); 89 | bool ReadFileNames(char* pcPrefix, char* pcSuffix); 90 | void GetNthFile(int iNthFile, char* pcFileName); 91 | void GetNthSerial(int iNthFile, char* pcSerial); 92 | int m_iNumFiles; 93 | private: 94 | bool mGetDirName(char* pcTemplate); 95 | bool mCountFiles(void); 96 | void mReadFileNames(void); 97 | void mClean(void); 98 | char* m_pcFileNames; 99 | int m_iBufSize; 100 | char m_acDirName[256]; 101 | char m_acPrefix[256]; 102 | char m_acSuffix[256]; 103 | }; 104 | 105 | } //namespace TiffUtil 106 | } //namespace MotionCor2 107 | 108 | -------------------------------------------------------------------------------- /TiffUtil/makefile: -------------------------------------------------------------------------------- 1 | TIFDIR = $(PROJDIR)/Tiffile 2 | INCDIR = $(PROJDIR)/libtiff/include 3 | 4 | SRCS = $(TIFDIR)/CLoadTiffImage.cpp \ 5 | $(TIFDIR)/CLoadTiffHeader.cpp \ 6 | $(TIFDIR)/CTiffHeader.cpp 7 | 8 | OBJS = $(patsubst %.cpp, %.o, $(SRCS)) 9 | OUT = libtiffile.a 10 | 11 | CC = g++ 12 | CFLAGS = -m64 -c -g -pthread -I$(INCDIR) -I$(TIFDIR)/Include 13 | 14 | all: $(OBJS) 15 | @ar rcs $(OUT) $(OBJS) 16 | @mv -f $(OUT) $(PROJDIR)/Lib 17 | @cp -f $(TIFDIR)/*.h $(PROJDIR)/Include/Tiffile 18 | @echo Static library $(OUT) has been created. 19 | 20 | compile: $(OBJS) 21 | @echo Compilation has been done. 22 | 23 | %.o: %.cpp 24 | @echo Compile $< 25 | @$(CC) $(CFLAGS) $< -o $@ 26 | 27 | clean: 28 | @rm -f $(OUT) $(OBJS) *.*~ makefile~ 29 | -------------------------------------------------------------------------------- /Util/CFileName.cpp: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::Util; 9 | 10 | CFileName::CFileName(void) 11 | { 12 | mReset(); 13 | } 14 | 15 | CFileName::~CFileName(void) 16 | { 17 | } 18 | 19 | void CFileName::Analyze(char* pcFileName) 20 | { 21 | mReset(); 22 | if(pcFileName == 0L) return; 23 | strcpy(m_acFileName, pcFileName); 24 | //------------------------------- 25 | mGetMainName(); 26 | mGetSerial(); 27 | } 28 | 29 | void CFileName::mReset(void) 30 | { 31 | m_bMrc = false; 32 | m_bTiff = false; 33 | m_iSerial = 0; 34 | memset(m_acFileName, 0, sizeof(m_acFileName)); 35 | memset(m_acMainName, 0, sizeof(m_acMainName)); 36 | } 37 | 38 | void CFileName::mGetMainName(void) 39 | { 40 | char* pcSlash = strrchr(m_acFileName, '/'); 41 | if(pcSlash == 0L) strcpy(m_acMainName, m_acFileName); 42 | else strcpy(m_acMainName, pcSlash + 1); 43 | //------------------------------------- 44 | char* pcMrc = strcasestr(m_acMainName, ".mrc"); 45 | if(pcMrc != 0L) 46 | { m_bMrc = true; 47 | m_bTiff = false; 48 | return; 49 | } 50 | //------------- 51 | char* pcTif = strcasestr(m_acMainName, ".tif"); 52 | if(pcTif != 0L) 53 | { m_bMrc = false; 54 | m_bTiff = true; 55 | return; 56 | } 57 | } 58 | 59 | void CFileName::mGetSerial(void) 60 | { 61 | m_iSerial = 0; 62 | int iSize = strlen(m_acMainName); 63 | if(iSize == 0) return; 64 | //-------------------- 65 | int iFactor = 1; 66 | for(int i=iSize-1; i>=0; i--) 67 | { if(!isdigit(m_acMainName[i])) 68 | { if(iFactor > 1) break; 69 | else continue; 70 | } 71 | int iDigit = m_acMainName[i] - '0'; 72 | m_iSerial += (iDigit * iFactor); 73 | iFactor *= 10; 74 | } 75 | } 76 | 77 | 78 | 79 | -------------------------------------------------------------------------------- /Util/CFlipImage.cpp: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::Util; 8 | 9 | CFlipImage::CFlipImage(void) 10 | { 11 | } 12 | 13 | CFlipImage::~CFlipImage(void) 14 | { 15 | } 16 | 17 | float* CFlipImage::DoIt(float* pfImg, int* piImgSize, bool bClean) 18 | { 19 | if(pfImg == 0L) return 0L; 20 | int iPixels = piImgSize[0] * piImgSize[1]; 21 | float* pfFlip = new float[iPixels]; 22 | //--------------------------------- 23 | int iEndY = piImgSize[1] - 1; 24 | int iBytes = sizeof(float) * piImgSize[0]; 25 | for(int y=0; yDoIt(pfImg, piImgSize, false); 39 | size_t tBytes = sizeof(float) * piImgSize[0] * piImgSize[1]; 40 | memcpy(pfImg, pfFlip, tBytes); 41 | } 42 | 43 | -------------------------------------------------------------------------------- /Util/CFourierCrop2D.cpp: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::Util; 9 | 10 | CFourierCrop2D::CFourierCrop2D(void) 11 | { 12 | } 13 | 14 | CFourierCrop2D::~CFourierCrop2D(void) 15 | { 16 | this->Clear(); 17 | } 18 | 19 | void CFourierCrop2D::Clear(void) 20 | { 21 | m_aCufft2D.DestroyPlan(); 22 | } 23 | 24 | void CFourierCrop2D::Setup(int* piCmpSize, float fBin) 25 | { 26 | m_aiInCmpSize[0] = piCmpSize[0]; 27 | m_aiInCmpSize[1] = piCmpSize[1]; 28 | //------------------------------ 29 | GFourierResize2D::GetBinnedCmpSize(m_aiInCmpSize, 30 | fBin, m_aiOutCmpSize); 31 | m_aCufft2D.CreateInversePlan(m_aiOutCmpSize, true); 32 | } 33 | 34 | void CFourierCrop2D::Setup(int* piCmpSizeIn, int* piCmpSizeOut) 35 | { 36 | memcpy(m_aiInCmpSize, piCmpSizeIn, sizeof(int) * 2); 37 | memcpy(m_aiOutCmpSize, piCmpSizeOut, sizeof(int) * 2); 38 | m_aCufft2D.CreateInversePlan(m_aiOutCmpSize, true); 39 | } 40 | 41 | void CFourierCrop2D::DoIt 42 | ( cufftComplex* gCmp, 43 | cufftComplex* gCmpBuf, 44 | float* gfImg, 45 | cudaStream_t stream 46 | ) 47 | { GFourierResize2D fourierResize; 48 | fourierResize.DoIt 49 | ( gCmp, m_aiInCmpSize, gCmpBuf, m_aiOutCmpSize, false, stream); 50 | ///------------------------------------------------------------ 51 | m_aCufft2D.Inverse(gCmpBuf, stream); 52 | int aiPadSize[] = {m_aiOutCmpSize[0] * 2, m_aiOutCmpSize[1]}; 53 | float* gfPadImg = reinterpret_cast(gCmpBuf); 54 | //-------------------------------------------------- 55 | GPad2D aGPad2D; 56 | aGPad2D.Unpad(gfPadImg, aiPadSize, gfImg, stream); 57 | } 58 | 59 | void CFourierCrop2D::GetCmpSize 60 | ( int* piCmpSizeIn, 61 | float fBin, 62 | int* piCmpSizeOut 63 | ) 64 | { GFourierResize2D::GetBinnedCmpSize(piCmpSizeIn, 65 | fBin, piCmpSizeOut); 66 | } 67 | 68 | void CFourierCrop2D::GetImgSize 69 | ( int* piCmpSizeIn, 70 | float fBin, 71 | int* piImgSizeOut 72 | ) 73 | { GFourierResize2D::GetBinnedCmpSize(piCmpSizeIn, fBin, piImgSizeOut); 74 | piImgSizeOut[0] = (piImgSizeOut[0] - 1) * 2; 75 | } 76 | -------------------------------------------------------------------------------- /Util/CGroupFrames.cpp: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | 6 | using namespace MotionCor2::Util; 7 | 8 | CGroupFrames::CGroupFrames(void) 9 | { 10 | m_piGroupStarts = 0L; 11 | m_piGroupSizes = 0L; 12 | m_iNumGroups = 0; 13 | m_iGroupSize = 0; 14 | } 15 | 16 | CGroupFrames::~CGroupFrames(void) 17 | { 18 | this->mClean(); 19 | } 20 | 21 | void CGroupFrames::DoGroupSize 22 | ( int iNumFrames, // total frames in raw stack 23 | int iGroupSize // number of frames per group 24 | ) 25 | { mClean(); 26 | //------- 27 | m_iNumFrames = iNumFrames; 28 | m_iGroupSize = iGroupSize; 29 | if(m_iGroupSize < 1) m_iGroupSize = 1; 30 | else if(m_iGroupSize > m_iNumFrames) m_iGroupSize = m_iNumFrames; 31 | //--------------------------------------------------------------- 32 | m_iNumGroups = m_iNumFrames / m_iGroupSize; 33 | mGroup(); 34 | } 35 | 36 | void CGroupFrames::DoNumGroups 37 | ( int iNumFrames, 38 | int iNumGroups 39 | ) 40 | { int iGroupSize = iNumFrames / iNumGroups; 41 | if(iGroupSize < 1) iGroupSize = 1; 42 | this->DoGroupSize(iNumFrames, iGroupSize); 43 | } 44 | 45 | int CGroupFrames::GetGroupStart(int iGroup) 46 | { 47 | return m_piGroupStarts[iGroup]; 48 | } 49 | 50 | int CGroupFrames::GetGroupSize(int iGroup) 51 | { 52 | return m_piGroupSizes[iGroup]; 53 | } 54 | 55 | int CGroupFrames::GetNumGroups(void) 56 | { 57 | return m_iNumGroups; 58 | } 59 | 60 | int CGroupFrames::GetNumFrames(void) 61 | { 62 | return m_iNumFrames; 63 | } 64 | 65 | int CGroupFrames::GetGroup(int iFrame) 66 | { 67 | int iGroup = iFrame / m_iGroupSize; 68 | //--------------------------------- 69 | int iStart = m_piGroupStarts[iGroup]; 70 | int iEnd = iStart + m_piGroupSizes[iGroup] - 1; 71 | if(iFrame < iStart) iGroup -= 1; 72 | else if(iFrame > iEnd) iGroup += 1; 73 | //--------------------------------- 74 | if(iGroup < 0) iGroup = 0; 75 | else if(iGroup >= m_iNumGroups) iGroup = m_iNumGroups - 1; 76 | //-------------------------------------------------------- 77 | return iGroup; 78 | } 79 | 80 | void CGroupFrames::mClean(void) 81 | { 82 | if(m_piGroupStarts != 0L) delete[] m_piGroupStarts; 83 | if(m_piGroupSizes != 0L) delete[] m_piGroupSizes; 84 | m_piGroupStarts = 0L; 85 | m_piGroupSizes = 0L; 86 | m_iNumGroups = 0; 87 | } 88 | 89 | void CGroupFrames::mGroup(void) 90 | { 91 | int iLeft = m_iNumFrames % m_iGroupSize; 92 | //-------------------------------------- 93 | m_piGroupSizes = new int[m_iNumGroups]; 94 | for(int i=0; i 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::Util; 9 | 10 | CMultiGpuBase::CMultiGpuBase(void) 11 | { 12 | m_pStreams = 0L; 13 | m_pForwardFFTs = 0L; 14 | m_pInverseFFTs = 0L; 15 | m_piGpuIDs = 0L; 16 | m_iNumGpus = 0; 17 | } 18 | 19 | CMultiGpuBase::~CMultiGpuBase(void) 20 | { 21 | this->mCleanAll(); 22 | } 23 | 24 | void CMultiGpuBase::mCleanAll(void) 25 | { 26 | this->mDeleteForwardFFTs(); 27 | this->mDeleteInverseFFTs(); 28 | this->mDeleteStreams(); 29 | if(m_piGpuIDs != 0L) delete[] m_piGpuIDs; 30 | m_piGpuIDs = 0L; 31 | } 32 | 33 | void CMultiGpuBase::mSetGpus(int* piGpuIDs, int iNumGpus) 34 | { 35 | this->mCleanAll(); 36 | //---------------- 37 | m_piGpuIDs = new int[iNumGpus]; 38 | memcpy(m_piGpuIDs, piGpuIDs, sizeof(int) * iNumGpus); 39 | m_iNumGpus = iNumGpus; 40 | } 41 | 42 | void CMultiGpuBase::mCreateStreams(int iStreamsPerGpu) 43 | { 44 | if(m_iNumGpus <= 0) return; 45 | m_iStreamsPerGpu = iStreamsPerGpu; 46 | //-------------------------------- 47 | m_pStreams = new cudaStream_t[m_iStreamsPerGpu * m_iNumGpus]; 48 | for(int i=0; i 3 | 4 | using namespace MotionCor2::Util; 5 | 6 | CNextItem::CNextItem(void) 7 | { 8 | pthread_mutex_init(&m_aMutex, 0L); 9 | } 10 | 11 | CNextItem::~CNextItem(void) 12 | { 13 | pthread_mutex_destroy(&m_aMutex); 14 | } 15 | 16 | void CNextItem::Create(int iNumItems) 17 | { 18 | m_iNumItems = iNumItems; 19 | m_iNextItem = 0; 20 | } 21 | 22 | void CNextItem::Reset(void) 23 | { 24 | m_iNextItem = 0; 25 | } 26 | 27 | int CNextItem::GetNext(void) 28 | { 29 | if(m_iNumItems <= 0) return -1; 30 | //----------------------------- 31 | int iNext = -1; 32 | pthread_mutex_lock(&m_aMutex); 33 | if(m_iNextItem < m_iNumItems) 34 | { iNext = m_iNextItem; 35 | m_iNextItem++; 36 | } 37 | pthread_mutex_unlock(&m_aMutex); 38 | return iNext; 39 | } 40 | 41 | int CNextItem::GetNumItems(void) 42 | { 43 | return m_iNumItems; 44 | } 45 | 46 | -------------------------------------------------------------------------------- /Util/CPad2D.cpp: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::Util; 8 | 9 | CPad2D::CPad2D(void) 10 | { 11 | } 12 | 13 | CPad2D::~CPad2D(void) 14 | { 15 | } 16 | 17 | void CPad2D::GetPadSize(int* piImgSize, int* piPadSize) 18 | { 19 | piPadSize[0] = (piImgSize[0] / 2 + 1) * 2; 20 | piPadSize[1] = piImgSize[1]; 21 | } 22 | 23 | void CPad2D::GetImgSize(int* piPadSize, int* piImgSize) 24 | { 25 | piImgSize[0] = (piPadSize[0] / 2 - 1) * 2; 26 | piImgSize[1] = piPadSize[1]; 27 | } 28 | 29 | float* CPad2D::GGetPadBuf(int* piImgSize, bool bZero) 30 | { 31 | int aiPadSize[2] = {0}; 32 | CPad2D::GetPadSize(piImgSize, aiPadSize); 33 | //--------------------------------------- 34 | float* gfPadBuf = Util::GGetFloatBuf(aiPadSize, bZero); 35 | return gfPadBuf; 36 | } 37 | 38 | float* CPad2D::CGetPadBuf(int* piImgSize, bool bZero) 39 | { 40 | int aiPadSize[2] = {0}; 41 | CPad2D::GetPadSize(piImgSize, aiPadSize); 42 | //--------------------------------------- 43 | float* pfPadBuf = Util::CGetFloatBuf(aiPadSize, bZero); 44 | return pfPadBuf; 45 | } 46 | 47 | float* CPad2D::GGetImgBuf(int* piPadSize, bool bZero) 48 | { 49 | int aiImgSize[2] = {0}; 50 | CPad2D::GetImgSize(piPadSize, aiImgSize); 51 | //--------------------------------------- 52 | float* gfImgBuf = Util::GGetFloatBuf(aiImgSize, bZero); 53 | return gfImgBuf; 54 | } 55 | 56 | float* CPad2D::CGetImgBuf(int* piPadSize, bool bZero) 57 | { 58 | int aiImgSize[2] = {0}; 59 | CPad2D::GetImgSize(piPadSize, aiImgSize); 60 | //--------------------------------------- 61 | float* pfImgBuf = Util::CGetFloatBuf(aiImgSize, bZero); 62 | return pfImgBuf; 63 | } 64 | 65 | float* CPad2D::GPad(float* pfImg, int* piSize) 66 | { 67 | float* gfPad = CPad2D::GGetPadBuf(piSize, false); 68 | this->Pad(pfImg, piSize, gfPad); 69 | return gfPad; 70 | } 71 | 72 | float* CPad2D::CPad(float* pfImg, int* piSize) 73 | { 74 | float* pfPad = CPad2D::CGetPadBuf(piSize, false); 75 | this->Pad(pfImg, piSize, pfPad); 76 | return pfPad; 77 | } 78 | 79 | void CPad2D::Pad(float* pfImg, int* piImgSize, float* pfPad) 80 | { 81 | int iBytes = piImgSize[0] * sizeof(float); 82 | int iPadX = (piImgSize[0] / 2 + 1) * 2; 83 | //------------------------------------- 84 | for(int y=0; yUnpad(pfPad, piSize, gfImg); 95 | return gfImg; 96 | } 97 | 98 | float* CPad2D::CUnpad(float* pfPad, int* piSize) 99 | { 100 | float* pfImg = CPad2D::CGetImgBuf(piSize, false); 101 | this->Unpad(pfPad, piSize, pfImg); 102 | return pfImg; 103 | } 104 | 105 | void CPad2D::Unpad(float* pfPad, int* piPadSize, float* pfImg) 106 | { 107 | int iImageX = (piPadSize[0] / 2 - 1) * 2; 108 | int iBytes = iImageX * sizeof(float); 109 | //----------------------------------- 110 | for(int y=0; y 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | 9 | using namespace MotionCor2::Util; 10 | 11 | CParseArgs::CParseArgs(void) 12 | { 13 | } 14 | 15 | CParseArgs::~CParseArgs(void) 16 | { 17 | } 18 | 19 | void CParseArgs::Set(int argc, char* argv[]) 20 | { 21 | m_argc = argc; 22 | m_argv = argv; 23 | } 24 | 25 | bool CParseArgs::FindVals(const char* pcTag, int aiRange[2]) 26 | { 27 | aiRange[0] = -1; 28 | aiRange[1] = 0; 29 | for(int i=1; i= 2) 40 | { if(isalpha(argv[1]) != 0) break; 41 | } 42 | strcpy(acBuf, argv); 43 | char* pcTok = strtok(acBuf, ", "); 44 | while(pcTok != 0L) 45 | { aiRange[1] += 1; 46 | pcTok = strtok(0L, ", "); 47 | } 48 | } 49 | //---------------------- 50 | if(aiRange[1] > 0) return true; 51 | else return false; 52 | } 53 | 54 | void CParseArgs::GetVals(int aiRange[2], float* pfVals) 55 | { 56 | if(aiRange[0] == -1) return; 57 | else if(aiRange[1] == 0) return; 58 | //------------------------------ 59 | for(int i=0; i= m_argc) return; 62 | sscanf(m_argv[j], "%f", pfVals + i); 63 | } 64 | } 65 | 66 | void CParseArgs::GetVals(int aiRange[2], int* piVals) 67 | { 68 | if(aiRange[0] == -1) return; 69 | else if(aiRange[1] == 0) return; 70 | //------------------------------ 71 | int iCount = 0; 72 | char acBuf[256]; 73 | for(int i=0; i= m_argc) return; 76 | //--------------------- 77 | strcpy(acBuf, m_argv[j]); 78 | char* pcTok = strtok(acBuf, ", "); 79 | while(pcTok != 0L) 80 | { sscanf(pcTok, "%d", piVals + iCount); 81 | iCount++; 82 | if(iCount == aiRange[1]) return; 83 | pcTok = strtok(0L, ", "); 84 | } 85 | } 86 | } 87 | 88 | void CParseArgs::GetVals(int aiRange[2], char** ppcVals) 89 | { 90 | if(aiRange[0] == -1) return; 91 | else if(aiRange[1] == 0) return; 92 | //------------------------------ 93 | for(int i=0; i= m_argc) return; 96 | strcpy(ppcVals[i], m_argv[j]); 97 | } 98 | } 99 | 100 | void CParseArgs::GetVal(int iArg, char* pcVal) 101 | { 102 | if(iArg <= 0 || iArg >= m_argc) return; 103 | strcpy(pcVal, m_argv[iArg]); 104 | } 105 | -------------------------------------------------------------------------------- /Util/CSaveTempMrc.cpp: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::Util; 8 | 9 | CSaveTempMrc::CSaveTempMrc(void) 10 | { 11 | } 12 | 13 | CSaveTempMrc::~CSaveTempMrc(void) 14 | { 15 | } 16 | 17 | void CSaveTempMrc::SetFile(char* pcMain, const char* pcMinor) 18 | { 19 | memset(m_acMrcFile, 0, sizeof(m_acMrcFile)); 20 | if(pcMain == 0L) return; 21 | //----------------- 22 | strcpy(m_acMrcFile, pcMain); 23 | char* pcExt = strstr(m_acMrcFile, ".mrc"); 24 | if(pcExt != 0L) pcExt[0] = '\0'; 25 | //----------------- 26 | if(pcMinor != 0L && strlen(pcMinor) > 0) 27 | { strcat(m_acMrcFile, pcMinor); 28 | } 29 | //----------------- 30 | if(strstr(m_acMrcFile, ".mrc")) return; 31 | else strcat(m_acMrcFile, ".mrc"); 32 | } 33 | 34 | void CSaveTempMrc::GDoIt(cufftComplex* gCmp, int* piCmpSize) 35 | { 36 | int aiPadSize[]= {0, piCmpSize[1]}; 37 | aiPadSize[0] = piCmpSize[0] * 2; 38 | //------------------------------ 39 | CCufft2D cufft2D; 40 | cufft2D.CreateInversePlan(piCmpSize, true); 41 | cufft2D.Inverse(gCmp); 42 | //-------------------- 43 | this->GDoIt((float*)gCmp, aiPadSize); 44 | //----------------------------------- 45 | cufft2D.CreateForwardPlan(aiPadSize, true); 46 | cufft2D.Forward((float*)gCmp, aiPadSize); 47 | } 48 | 49 | void CSaveTempMrc::GDoIt(float* gfImg, int* piSize) 50 | { 51 | int iPixels = piSize[0] * piSize[1]; 52 | size_t tBytes = iPixels * sizeof(float); 53 | float* pfBuf = new float[iPixels]; 54 | cudaMemcpy(pfBuf, gfImg, tBytes, cudaMemcpyDeviceToHost); 55 | this->DoIt(pfBuf, Mrc::eMrcFloat, piSize); 56 | delete[] pfBuf; 57 | } 58 | 59 | void CSaveTempMrc::GDoIt(unsigned char* gucImg, int* piSize) 60 | { 61 | int iPixels = piSize[0] * piSize[1]; 62 | size_t tBytes = iPixels * sizeof(char); 63 | unsigned char* pucBuf = new unsigned char[iPixels]; 64 | cudaMemcpy(pucBuf, gucImg, tBytes, cudaMemcpyDeviceToHost); 65 | this->DoIt(pucBuf, Mrc::eMrcUChar, piSize); 66 | delete[] pucBuf; 67 | } 68 | 69 | void CSaveTempMrc::DoIt(void* pvImg, int iMode, int* piSize) 70 | { 71 | Mrc::CSaveMrc aSaveMrc; 72 | if(!aSaveMrc.OpenFile(m_acMrcFile)) return; 73 | //----------------------------------------- 74 | aSaveMrc.SetMode(iMode); 75 | aSaveMrc.SetImgSize(piSize, 1, 1, 1.0f); 76 | aSaveMrc.SetExtHeader(0, 0, 0); 77 | aSaveMrc.DoIt(0, pvImg); 78 | } 79 | 80 | -------------------------------------------------------------------------------- /Util/CSplineFit1D.cpp: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::Util; 8 | 9 | CSplineFit1D::CSplineFit1D(void) 10 | { 11 | m_pfTerms = 0L; 12 | m_pfCoeff = 0L; 13 | m_pfMatrix = 0L; 14 | } 15 | 16 | CSplineFit1D::~CSplineFit1D(void) 17 | { 18 | this->Clean(); 19 | } 20 | 21 | void CSplineFit1D::Clean(void) 22 | { 23 | if(m_pfTerms != 0L) delete[] m_pfTerms; 24 | if(m_pfCoeff != 0L) delete[] m_pfCoeff; 25 | if(m_pfMatrix != 0L) delete[] m_pfMatrix; 26 | m_pfTerms = 0L; 27 | m_pfCoeff = 0L; 28 | m_pfMatrix = 0L; 29 | } 30 | 31 | void CSplineFit1D::SetNumKnots(int iNumKnots) 32 | { 33 | this->Clean(); 34 | //------------ 35 | m_iNumKnots = iNumKnots; 36 | m_iDim = m_iNumKnots + 3; 37 | //----------------------- 38 | m_pfTerms = new float[m_iDim * 2]; 39 | m_pfCoeff = new float[m_iDim]; 40 | m_pfMatrix = new float[m_iDim * m_iDim]; 41 | } 42 | 43 | bool CSplineFit1D::DoIt 44 | ( float* pfX, float* pfY, bool* pbBad, int iSize, 45 | float* pfKnots, float* pfFit, float fReg 46 | ) 47 | { m_pfKnots = pfKnots; 48 | //------------------ 49 | memset(m_pfMatrix, 0, sizeof(float) * m_iDim * m_iDim); 50 | memset(m_pfCoeff, 0, sizeof(float) * m_iDim); 51 | memset(m_pfTerms, 0, sizeof(float) * m_iDim * 2); 52 | float* pfCurTerms = m_pfTerms + m_iDim; 53 | //------------------------------------- 54 | for(int i=0; i 0) break; 113 | pfCurTerms[i+3] = 2.0f * fVal; 114 | } 115 | } 116 | 117 | 118 | 119 | -------------------------------------------------------------------------------- /Util/GAddFrames.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::Util; 8 | 9 | static __global__ void mGAddFloat 10 | ( float* gfFrame1, float fFactor1, 11 | float* gfFrame2, float fFactor2, 12 | float* gfSum, int nxy 13 | ) 14 | { int i = blockIdx.x * blockDim.x + threadIdx.x; 15 | if (i >= nxy) return; 16 | gfSum[i] = gfFrame1[i] * fFactor1 + gfFrame2[i] * fFactor2; 17 | } 18 | 19 | static __global__ void mGAddComplex 20 | ( cufftComplex* gCmp1, float fFactor1, 21 | cufftComplex* gCmp2, float fFactor2, 22 | cufftComplex* gCmpSum, int nxy 23 | ) 24 | { int i = blockIdx.x * blockDim.x + threadIdx.x; 25 | if (i >= nxy) return; 26 | cufftComplex res; 27 | res.x = gCmp1[i].x * fFactor1 + gCmp2[i].x * fFactor2; 28 | res.y = gCmp1[i].y * fFactor1 + gCmp2[i].y * fFactor2; 29 | gCmpSum[i] = res; 30 | } 31 | 32 | static __global__ void mGAddUChar 33 | ( unsigned char* gucFrm1, 34 | unsigned char* gucFrm2, 35 | unsigned char* gucSum, 36 | int nxy 37 | ) 38 | { int i = blockIdx.x * blockDim.x + threadIdx.x; 39 | if(i >= nxy) return; 40 | gucSum[i] = gucFrm1[i] + gucFrm2[i]; 41 | } 42 | 43 | GAddFrames::GAddFrames(void) 44 | { 45 | } 46 | 47 | GAddFrames::~GAddFrames(void) 48 | { 49 | } 50 | 51 | void GAddFrames::DoIt 52 | ( float* gfFrame1, 53 | float fFactor1, 54 | float* gfFrame2, 55 | float fFactor2, 56 | float* gfSum, 57 | int* piFrmSize, 58 | cudaStream_t stream 59 | ) 60 | { int nxy = piFrmSize[0] * piFrmSize[1]; 61 | dim3 aBlockDim(512, 1, 1); 62 | dim3 aGridDim((nxy + aBlockDim.x - 1) / aBlockDim.x, 1, 1); 63 | mGAddFloat<<>> 64 | ( gfFrame1, fFactor1, 65 | gfFrame2, fFactor2, 66 | gfSum, nxy 67 | ); 68 | } 69 | 70 | void GAddFrames::DoIt 71 | ( cufftComplex* gCmp1, 72 | float fFactor1, 73 | cufftComplex* gCmp2, 74 | float fFactor2, 75 | cufftComplex* gCmpSum, 76 | int* piCmpSize, 77 | cudaStream_t stream 78 | ) 79 | { int nxy = piCmpSize[0] * piCmpSize[1]; 80 | dim3 aBlockDim(512, 1, 1); 81 | dim3 aGridDim((nxy + aBlockDim.x - 1) / aBlockDim.x, 1, 1); 82 | mGAddComplex<<>> 83 | ( gCmp1, fFactor1, 84 | gCmp2, fFactor2, 85 | gCmpSum, nxy 86 | ); 87 | } 88 | 89 | void GAddFrames::DoIt 90 | ( unsigned char* gucFrm1, 91 | unsigned char* gucFrm2, 92 | unsigned char* gucSum, 93 | int* piFrmSize, 94 | cudaStream_t stream 95 | ) 96 | { int nxy = piFrmSize[0] * piFrmSize[1]; 97 | dim3 aBlockDim(128, 1, 1); 98 | dim3 aGridDim((nxy + aBlockDim.x - 1) / aBlockDim.x, 1, 1); 99 | mGAddUChar<<>>(gucFrm1, 100 | gucFrm2, gucSum, nxy); 101 | } 102 | -------------------------------------------------------------------------------- /Util/GCorrLinearInterp.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | 5 | using namespace MotionCor2::Util; 6 | 7 | static __global__ void mGCorrectCmp 8 | ( cufftComplex* gCmpFrm, 9 | int iCmpSizeY 10 | ) 11 | { int iY = blockIdx.y * blockDim.y + threadIdx.y; 12 | if(iY >= iCmpSizeY) return; 13 | if(blockIdx.x == 0 && iY == 0) return; 14 | int i = iY * gridDim.x + blockIdx.x; 15 | //---------------------------------- 16 | float fX = blockIdx.x * 0.5f / (gridDim.x - 1); 17 | float fY = iY / (float)iCmpSizeY; 18 | if(fY > 0.5f) fY -= 1.0f; 19 | //----------------------- 20 | fX = sqrtf(fX * fX + fY * fY) * 3.141592654f; 21 | fX = sinf(fX) / fX; 22 | fX = powf(fX, 0.125f); 23 | //-------------------- 24 | gCmpFrm[i].x /= fX; 25 | gCmpFrm[i].y /= fX; 26 | } 27 | 28 | GCorrLinearInterp::GCorrLinearInterp(void) 29 | { 30 | } 31 | 32 | GCorrLinearInterp::~GCorrLinearInterp(void) 33 | { 34 | } 35 | 36 | void GCorrLinearInterp::DoIt 37 | ( cufftComplex* gCmpFrm, 38 | int* piCmpSize, 39 | cudaStream_t stream 40 | ) 41 | { dim3 aBlockDim(1, 512); 42 | int iGridY = (piCmpSize[1] + aBlockDim.y - 1) / aBlockDim.y; 43 | dim3 aGridDim(piCmpSize[0], iGridY); 44 | mGCorrectCmp<<>>(gCmpFrm, piCmpSize[1]); 45 | } 46 | 47 | -------------------------------------------------------------------------------- /Util/GFFT1D.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using namespace MotionCor2::Util; 9 | 10 | static __global__ void mGMultiply 11 | ( cufftComplex* gCmpLines, 12 | int iCmpSize, 13 | float fFactor 14 | ) 15 | { int i = blockIdx.x * blockDim.x + threadIdx.x; 16 | if(i >= iCmpSize) return; 17 | //----------------------- 18 | int j = blockIdx.y * iCmpSize + i; 19 | gCmpLines[j].x *= fFactor; 20 | gCmpLines[j].y *= fFactor; 21 | } 22 | 23 | GFFT1D::GFFT1D(void) 24 | { 25 | m_cufftPlan = 0; 26 | m_iFFTSize = 0; 27 | m_iNumLines = 0; 28 | m_cufftType = CUFFT_R2C; 29 | } 30 | 31 | GFFT1D::~GFFT1D(void) 32 | { 33 | this->DestroyPlan(); 34 | } 35 | 36 | void GFFT1D::DestroyPlan(void) 37 | { 38 | if(m_cufftPlan == 0) return; 39 | cufftDestroy(m_cufftPlan); 40 | m_cufftPlan = 0; 41 | m_iFFTSize = 0; 42 | m_iNumLines = 0; 43 | } 44 | 45 | void GFFT1D::CreatePlan(int iFFTSize, int iNumLines, bool bForward) 46 | { 47 | cufftType fftType = bForward ? CUFFT_R2C : CUFFT_C2R; 48 | if(fftType != m_cufftType) this->DestroyPlan(); 49 | else if(m_iFFTSize != iFFTSize) this->DestroyPlan(); 50 | else if(m_iNumLines != iNumLines) this->DestroyPlan(); 51 | if(m_cufftPlan != 0) return; 52 | //-------------------------- 53 | m_cufftType = fftType; 54 | m_iFFTSize = iFFTSize; 55 | m_iNumLines = iNumLines; 56 | //---------------------- 57 | cufftResult res = cufftPlan1d 58 | ( &m_cufftPlan, m_iFFTSize, m_cufftType, m_iNumLines 59 | ); 60 | } 61 | 62 | void GFFT1D::Forward 63 | ( float* gfPadLines, 64 | bool bNorm 65 | ) 66 | { cufftResult res = cufftExecR2C 67 | ( m_cufftPlan, (cufftReal*)gfPadLines, 68 | (cufftComplex*)gfPadLines 69 | ); 70 | if(!bNorm) return; 71 | //---------------- 72 | int iCmpSize = m_iFFTSize / 2 + 1; 73 | dim3 aBlockDim(512, 1); 74 | dim3 aGridDim(iCmpSize / aBlockDim.x + 1, m_iNumLines); 75 | float fFactor = 1.0f / m_iFFTSize; 76 | //-------------------------------- 77 | mGMultiply<<>> 78 | ( (cufftComplex*)gfPadLines, 79 | iCmpSize, fFactor 80 | ); 81 | } 82 | 83 | void GFFT1D::Inverse(cufftComplex* gCmpLines) 84 | { 85 | cufftResult res = cufftExecC2R 86 | ( m_cufftPlan, gCmpLines, (cufftReal*)gCmpLines 87 | ); 88 | } 89 | 90 | -------------------------------------------------------------------------------- /Util/GNormalize2D.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | 5 | using namespace MotionCor2::Util; 6 | 7 | static __global__ void mGNorm2D 8 | ( float* gfImg, 9 | int iPadX, 10 | int iSizeY, 11 | float fMean, 12 | float fStd 13 | ) 14 | { int y = blockIdx.y * blockDim.y + threadIdx.y; 15 | if(y >= iSizeY) return; 16 | //--------------------- 17 | int i = y * iPadX + blockIdx.x; 18 | float fInt = gfImg[i]; 19 | if(fInt < (float)-1e10) return; 20 | //----------------------------- 21 | gfImg[i] = (fInt - fMean) / fStd; 22 | } 23 | 24 | 25 | GNormalize2D::GNormalize2D(void) 26 | { 27 | } 28 | 29 | GNormalize2D::~GNormalize2D(void) 30 | { 31 | } 32 | 33 | void GNormalize2D::DoIt 34 | ( float* gfImg, 35 | int* piSize, 36 | bool bPadded, 37 | float fMean, 38 | float fStd, 39 | cudaStream_t stream 40 | ) 41 | { int iSizeX = bPadded ? (piSize[0] / 2 - 1) * 2 : piSize[0]; 42 | int iSizeY = piSize[1]; 43 | dim3 aBlockDim(1, 512); 44 | dim3 aGridDim(iSizeX, 1); 45 | aGridDim.y = (iSizeY + aBlockDim.y - 1) / aBlockDim.y; 46 | mGNorm2D<<>> 47 | ( gfImg, piSize[0], iSizeY, fMean, fStd 48 | ); 49 | } 50 | 51 | -------------------------------------------------------------------------------- /Util/GPad2D.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::Util; 8 | 9 | template 10 | static __global__ void mGPad(T* pSrc, int iSizeX, T* pDst) 11 | { 12 | int x = blockIdx.x * blockDim.x + threadIdx.x; 13 | if (x >= iSizeX) return; 14 | //---------------------- 15 | int iPadX = (iSizeX / 2 + 1) * 2; 16 | pDst[blockIdx.y * iPadX + x] = pSrc[blockIdx.y * iSizeX + x]; 17 | } 18 | 19 | template 20 | static __global__ void mGUnpad(T* pSrc, int iSizeX, T* pDst) 21 | { 22 | int x = blockIdx.x * blockDim.x + threadIdx.x; 23 | if(x >= iSizeX) return; 24 | //--------------------- 25 | int iPadX = (iSizeX / 2 + 1) * 2; 26 | pDst[blockIdx.y * iSizeX + x] = pSrc[blockIdx.y * iPadX + x]; 27 | } 28 | 29 | void GPad2D::Pad 30 | ( float* gfImg, 31 | int* piImgSize, 32 | float* gfPadImg, 33 | cudaStream_t stream 34 | ) 35 | { dim3 aBlockDim (64, 1, 1); 36 | dim3 aGridDim (piImgSize[0] / aBlockDim.x + 1, piImgSize[1]); 37 | mGPad<<>>(gfImg, 38 | piImgSize[0], gfPadImg); 39 | } 40 | 41 | void GPad2D::Unpad 42 | ( float* gfPadImg, 43 | int* piPadSize, 44 | float* gfImg, 45 | cudaStream_t stream 46 | ) 47 | { int iImgSizeX = (piPadSize[0] / 2 - 1) * 2; 48 | dim3 aBlockDim(64, 1, 1); 49 | dim3 aGridDim(iImgSizeX / aBlockDim.x + 1, piPadSize[1]); 50 | mGUnpad<<>>(gfPadImg, 51 | iImgSizeX, gfImg); 52 | } 53 | -------------------------------------------------------------------------------- /Util/GPartialCopy.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace MotionCor2::Util; 8 | 9 | template 10 | static __global__ void mGPartialCopy 11 | ( T* pSrc, 12 | int iSrcX, 13 | T* pDst, 14 | int iCpyX, 15 | int iDstX 16 | ) 17 | { int iX = blockIdx.x * blockDim.x + threadIdx.x; 18 | int iY = blockIdx.y; 19 | if (iX >= iCpyX) return; 20 | pDst[iY * iDstX + iX] = pSrc[iY * iSrcX + iX]; 21 | } 22 | 23 | void GPartialCopy::DoIt 24 | ( float* pSrc, 25 | int iSrcSizeX, 26 | float* pDst, 27 | int iCpySizeX, 28 | int* piDstSize, 29 | cudaStream_t stream 30 | ) 31 | { dim3 aBlockDim(64, 1, 1); 32 | dim3 aGridDim(1, piDstSize[1], 1); 33 | aGridDim.x = (iCpySizeX + aBlockDim.x - 1) / aBlockDim.x;; 34 | mGPartialCopy<<>> 35 | ( pSrc, iSrcSizeX, pDst, iCpySizeX, piDstSize[0] ); 36 | } 37 | 38 | void GPartialCopy::DoIt 39 | ( cufftComplex* pSrc, 40 | int iSrcSizeX, 41 | cufftComplex* pDst, 42 | int iCpySizeX, 43 | int* piDstSize, 44 | cudaStream_t stream 45 | ) 46 | { dim3 aBlockDim(64, 1, 1); 47 | dim3 aGridDim(1, piDstSize[1], 1); 48 | aGridDim.x = (iCpySizeX + aBlockDim.x - 1 ) / aBlockDim.x; 49 | mGPartialCopy<<>> 50 | ( pSrc, iSrcSizeX, pDst, iCpySizeX, piDstSize[0] ); 51 | } 52 | 53 | -------------------------------------------------------------------------------- /Util/GPhaseShift2D.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include "../MrcUtil/CMrcUtilInc.h" 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | #define OPT_NVIDIA 9 | 10 | using namespace MotionCor2::Util; 11 | 12 | static __global__ void mGShiftFrame 13 | ( cufftComplex* gInCmp, 14 | float fShiftX, 15 | float fShiftY, 16 | bool bSum, 17 | cufftComplex* gOutCmp, 18 | int iCmpY 19 | ) 20 | { int y = blockIdx.y * blockDim.y + threadIdx.y; 21 | if (y >= iCmpY) return; 22 | int i = y * gridDim.x + blockIdx.x; 23 | //--------------------------------- 24 | if(y > (iCmpY / 2)) y -= iCmpY; 25 | float fPhaseShift = blockIdx.x * fShiftX + y * fShiftY; 26 | float fCos = cosf(fPhaseShift); 27 | float fSin = sinf(fPhaseShift); 28 | //----------------------------- 29 | cufftComplex res; 30 | res.x = fCos * gInCmp[i].x - fSin * gInCmp[i].y; 31 | res.y = fCos * gInCmp[i].y + fSin * gInCmp[i].x; 32 | //---------------------------------------------- 33 | if(bSum) 34 | { gOutCmp[i].x += res.x; 35 | gOutCmp[i].y += res.y; 36 | } 37 | else gOutCmp[i] = res; 38 | } 39 | 40 | GPhaseShift2D::GPhaseShift2D(void) 41 | { 42 | } 43 | 44 | GPhaseShift2D::~GPhaseShift2D(void) 45 | { 46 | } 47 | 48 | void GPhaseShift2D::DoIt 49 | ( cufftComplex* gInCmp, 50 | int* piCmpSize, 51 | float* pfShift, 52 | bool bSum, 53 | cufftComplex* gOutCmp, 54 | cudaStream_t stream 55 | ) 56 | { float f2PI = (float)(8 * atan(1.0)); 57 | int iNx = (piCmpSize[0] - 1) * 2; 58 | float fShiftX = pfShift[0] * (f2PI / iNx); 59 | float fShiftY = pfShift[1] * (f2PI / piCmpSize[1]); 60 | //------------------------------------------------- 61 | dim3 aBlockDim(1, 64); 62 | dim3 aGridDim(piCmpSize[0], 1); 63 | aGridDim.y = (piCmpSize[1] + aBlockDim.y - 1) / aBlockDim.y; 64 | mGShiftFrame<<>>(gInCmp, 65 | fShiftX, fShiftY, bSum, gOutCmp, piCmpSize[1]); 66 | } 67 | 68 | void GPhaseShift2D::DoIt 69 | ( cufftComplex* gCmpFrm, 70 | int* piCmpSize, 71 | float* pfShift, 72 | cudaStream_t stream 73 | ) 74 | { double dShift = sqrtf(pfShift[0] * pfShift[0] 75 | + pfShift[1] * pfShift[1]); 76 | if(dShift < 0.1) return; 77 | //---------------------- 78 | this->DoIt(gCmpFrm, piCmpSize, pfShift, false, gCmpFrm, stream); 79 | } 80 | -------------------------------------------------------------------------------- /Util/GPositivity2D.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | 5 | using namespace MotionCor2::Util; 6 | 7 | static __global__ void mGPositivity2D 8 | ( float* gfImg, 9 | int iSizeX 10 | ) 11 | { int x = blockIdx.x * blockDim.x + threadIdx.x; 12 | if(x >= iSizeX) return; 13 | int i = blockIdx.y * iSizeX + x; 14 | gfImg[i] = fmax(0.0f, gfImg[i]); 15 | } 16 | 17 | static __global__ void mGAddVal(float* gfImg, int iPixels, float fVal) 18 | { 19 | int i = blockIdx.x * blockDim.x + threadIdx.x; 20 | if(i >= iPixels) return; 21 | gfImg[i] += fVal; 22 | } 23 | 24 | GPositivity2D::GPositivity2D(void) 25 | { 26 | } 27 | 28 | GPositivity2D::~GPositivity2D(void) 29 | { 30 | } 31 | 32 | void GPositivity2D::DoIt(float* gfImg, int* piImgSize, cudaStream_t stream) 33 | { 34 | if(gfImg == 0L) return; 35 | //--------------------- 36 | dim3 aBlockDim(512, 1); 37 | dim3 aGridDim(piImgSize[0] / aBlockDim.x + 1, piImgSize[1]); 38 | mGPositivity2D<<>>(gfImg, piImgSize[0]); 39 | } 40 | 41 | void GPositivity2D::AddVal(float* gfImg, int* piImgSize, float fVal, 42 | cudaStream_t stream) 43 | { 44 | if(gfImg == 0L) return; 45 | int iPixels = piImgSize[0] * piImgSize[1]; 46 | dim3 aBlockDim(512, 1); 47 | dim3 aGridDim( (iPixels + aBlockDim.x - 1) / aBlockDim.x, 1); 48 | mGAddVal<<>>(gfImg, iPixels, fVal); 49 | } 50 | -------------------------------------------------------------------------------- /Util/GRoundEdge.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | 5 | using namespace MotionCor2::Util; 6 | 7 | static __global__ void mGRoundEdge(float* gfImg, int iSizeX, 8 | float* gfMaskCent, float* gfMaskSize, float fScale) 9 | { 10 | int x = blockIdx.x * blockDim.x + threadIdx.x; 11 | if(x >= iSizeX) return; 12 | int i = blockIdx.y * iSizeX + x; 13 | //------------------------------------ 14 | float fX = 2 * fabsf(x - gfMaskCent[0]) / gfMaskSize[0]; 15 | float fY = 2 * fabsf(blockIdx.y - gfMaskCent[1]) / gfMaskSize[1]; 16 | float fR = sqrtf(fX * fX + fY * fY); 17 | if(fR >= 1.0f) 18 | { gfImg[i] = 0.0f; 19 | return; 20 | } 21 | //------------- 22 | fR = 0.5f * (1 - cosf(3.1415926f * fR)); 23 | fR = 1.0f - powf(fR, 3.0f); 24 | gfImg[i] = (gfImg[i] * fR) * fScale; 25 | } 26 | 27 | 28 | GRoundEdge::GRoundEdge(void) 29 | { 30 | m_fScale = 1.0f; 31 | } 32 | 33 | GRoundEdge::~GRoundEdge(void) 34 | { 35 | } 36 | 37 | void GRoundEdge::SetMask(float* pfCent, float* pfSize) 38 | { 39 | m_afMaskCent[0] = pfCent[0]; 40 | m_afMaskCent[1] = pfCent[1]; 41 | m_afMaskSize[0] = pfSize[0]; 42 | m_afMaskSize[1] = pfSize[1]; 43 | } 44 | 45 | void GRoundEdge::SetScale(float fScale) 46 | { 47 | m_fScale = fScale; 48 | } 49 | 50 | void GRoundEdge::DoIt(float* gfImg, int* piImgSize) 51 | { 52 | size_t tBytes = 0; 53 | cudaMemcpyKind aH2D = cudaMemcpyHostToDevice; 54 | //------------------------------------------- 55 | float* gfMaskCent = 0L; 56 | tBytes = sizeof(float) * 2; 57 | cudaMalloc(&gfMaskCent, tBytes); 58 | cudaMemcpy(gfMaskCent, m_afMaskCent, tBytes, aH2D); 59 | //------------------------------------------------- 60 | float* gfMaskSize = 0L; 61 | cudaMalloc(&gfMaskSize, tBytes); 62 | cudaMemcpy(gfMaskSize, m_afMaskSize, tBytes, aH2D); 63 | //------------------------------------------------- 64 | dim3 aBlockDim(512, 1); 65 | int iGridX = piImgSize[0] / aBlockDim.x + 1; 66 | dim3 aGridDim(iGridX, piImgSize[1]); 67 | //---------------------------------- 68 | mGRoundEdge<<>>(gfImg, piImgSize[0], 69 | gfMaskCent, gfMaskSize, m_fScale); 70 | //---------------------------------------- 71 | if(gfMaskCent != 0L) cudaFree(gfMaskCent); 72 | if(gfMaskSize != 0L) cudaFree(gfMaskSize); 73 | } 74 | -------------------------------------------------------------------------------- /Util/GThreshold2D.cu: -------------------------------------------------------------------------------- 1 | #include "CUtilInc.h" 2 | #include 3 | #include 4 | 5 | using namespace MotionCor2::Util; 6 | 7 | static __global__ void mGThreshold2D 8 | ( float* gfImg, 9 | float fMin, 10 | float fMax, 11 | int iPadX, 12 | int iSizeY 13 | ) 14 | { int y = blockIdx.y * blockDim.y + threadIdx.y; 15 | if(y >= iSizeY) return; 16 | int i = y * iPadX + blockIdx.x; 17 | float fInt = gfImg[i]; 18 | if(fInt <= (float)-1e20) return; 19 | else if(gfImg[i] < fMin) gfImg[i] = fMin; 20 | else if(gfImg[i] > fMax) gfImg[i] = fMax; 21 | } 22 | 23 | GThreshold2D::GThreshold2D(void) 24 | { 25 | } 26 | 27 | GThreshold2D::~GThreshold2D(void) 28 | { 29 | } 30 | 31 | void GThreshold2D::DoIt 32 | ( float* gfImg, int* piImgSize, bool bPadded, 33 | float fMin, float fMax 34 | ) 35 | { int iSizeX = piImgSize[0]; 36 | if(bPadded) iSizeX = (piImgSize[0] / 2 - 1) * 2; 37 | dim3 aBlockDim(1, 512); 38 | dim3 aGridDim(iSizeX, 1); 39 | aGridDim.y = (piImgSize[1] + aBlockDim.y - 1) / aBlockDim.y; 40 | mGThreshold2D<<>>(gfImg, fMin, fMax, 41 | piImgSize[0], piImgSize[1]); 42 | } 43 | -------------------------------------------------------------------------------- /docs/ReadmeImg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/czimaginginstitute/MotionCor3/f2cc4b1772f140fb44741502d4102a0e9f248ed2/docs/ReadmeImg.png --------------------------------------------------------------------------------