├── 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 <memory.h>
  6 | #include <stdio.h>
  7 | #include <cuda.h>
  8 | #include <cuda_runtime.h>
  9 | #include <cufft.h>
 10 | #include <nvToolsExt.h>
 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 <memory.h>
  5 | #include <stdio.h>
  6 | #include <cuda.h>
  7 | #include <cuda_runtime.h>
  8 | #include <cufft.h>
  9 | #include <nvToolsExt.h>
 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 <memory.h>
  4 | #include <stdio.h>
  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 <cuda.h>
 5 | #include <cuda_runtime.h>
 6 | #include <cufft.h>
 7 | #include <memory.h>
 8 | #include <stdio.h>
 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; i<iNumGpus; i++)
24 | 	{	pThreads[i].Run(pGFFTStack, pStackShift, &nextItem, i);
25 | 	};
26 | 	for(int i=0; i<iNumGpus; i++)
27 | 	{	pThreads[i].WaitForExit(-1.0f);
28 | 	}
29 | 	delete[] pThreads;
30 | }
31 | 
32 | CCorrFFTStack::CCorrFFTStack(void)
33 | {
34 | }
35 | 
36 | CCorrFFTStack::~CCorrFFTStack(void)
37 | {
38 | }
39 | 
40 | void CCorrFFTStack::Run
41 | (    MrcUtil::GFFTStack* pGFFTStack,
42 |      CStackShift* pStackShift,
43 |      Util::CNextItem* pNextItem, 
44 |      int iThreadId
45 | )
46 | {	m_pGFFTStack = pGFFTStack;
47 |      m_pStackShift = pStackShift;
48 | 	m_pNextItem = pNextItem;
49 | 	m_iThreadId = iThreadId;
50 | 	m_iGpuId = m_pGFFTStack->GetGpuId(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; i<m_pGFFTStack->m_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 <Util/Util_Time.h>
  5 | #include <memory.h>
  6 | #include <stdio.h>
  7 | #include <cuda.h>
  8 | #include <cuda_runtime.h>
  9 | #include <cufft.h>
 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; i<iNumGpus; i++)
 40 | 	{	pExtractPatch[i].Run(i);
 41 | 	}
 42 | 	for(int i=0; i<iNumGpus; i++)
 43 | 	{	pExtractPatch[i].Wait();
 44 | 	}
 45 | 	if(pExtractPatch != 0L) delete[] pExtractPatch;
 46 | }
 47 | 
 48 | void CExtractPatch::Run(int iNthGpu)
 49 | {	
 50 | 	m_iNthGpu = iNthGpu;
 51 | 	s_pPatBuffer->SetDevice(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; i<iNumFrames; i++)
 72 | 	{	if(!s_pPatBuffer->IsGpuFrame(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; i<iNumFrames; i++)
 82 | 	{	if(s_pPatBuffer->IsGpuFrame(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<float*>(gPatCmp);
 94 | 	float* gfXcfFrm = reinterpret_cast<float*>(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 <Util/Util_Time.h>
 5 | #include <memory.h>
 6 | #include <stdio.h>
 7 | #include <cuda.h>
 8 | #include <cuda_runtime.h>
 9 | #include <cufft.h>
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; i<iNumPatches; i++)
40 | 	{	CExtractPatch::DoIt(i);
41 | 		mCalcPatchShift(i);
42 | 	}
43 | 	m_pPatchShifts->MakeRelative();
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 <Util/Util_Time.h>
  5 | #include <memory.h>
  6 | #include <stdio.h>
  7 | #include <cuda.h>
  8 | #include <cuda_runtime.h>
  9 | #include <cufft.h>
 10 | #include <nvToolsExt.h>
 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 <stdio.h>
  3 | #include <memory.h>
  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<iEndY; y++)
 29 | 	{	double dY2 = (y - piPos[1]) * (y - piPos[1]);
 30 | 		int i = y * piImgSize[0];
 31 | 		for(int x=iStartX; x<iEndX; x++)
 32 | 		{	double dX2 = (x - piPos[0]) * (y - piPos[0]);
 33 | 			if(sqrt(dX2 + dY2) > 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<iPixels; i++)
 59 | 	{	if(m_fPeak >= 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 <memory.h>
 6 | #include <stdio.h>
 7 | #include <cuda.h>
 8 | #include <cuda_runtime.h>
 9 | #include <cufft.h>
10 | #include <nvToolsExt.h>
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; i<iNumGroups; i++)
42 | 	{	int iGroupStart = aFmGroupParam.GetGroupStart(i);
43 | 		int iGroupSize = aFmGroupParam.GetGroupSize(i);
44 | 		mGroup(i, iGroupStart, iGroupSize);
45 | 	}
46 | 	//-----------------------------------------------------
47 | 	// delete remaining frames in the aligned stack.
48 | 	//-----------------------------------------------------
49 | 	for(int i=iNumGroups; i<pAlnStack->m_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; i<iGroupSize; i++)
65 | 	{	pfFm = (float*)m_pMrcStack->GetFrame(i+iGroupStart);
66 | 		for(int j=0; j<iPixels; j++)
67 | 		{	pfBinnedFm[j] += pfFm[j];
68 | 		}
69 | 	}
70 | }
71 | 
72 | 


--------------------------------------------------------------------------------
/Align/GNormByStd2D.cu:
--------------------------------------------------------------------------------
 1 | #include "CAlignInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 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<iWinY; j++)
23 | 	{	int y = j + iOffsetY;
24 | 		if(y < 0) continue;
25 | 		else if(y >= gridDim.y) continue;
26 | 		for(int i=0; i<iWinX; i++)
27 | 		{	int x = i + iOffsetX;
28 | 			if(x < 0) continue;
29 | 			else if(x >= 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<<<aGridDim, aBlockDim, 0, stream>>>(gfImg, iImageX,
62 | 	   piImgSize[0], piWinSize[0], piWinSize[1]);
63 | }
64 | 


--------------------------------------------------------------------------------
/Align/GNormByStd2D_bak.cu:
--------------------------------------------------------------------------------
 1 | #include "CAlignInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 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<iWinY; y++)
28 | 	{	for(x=0; x<iWinX; x++)
29 | 		{	fVal = gfBlock[y * iPadX + x];
30 | 			fMean += (fVal * fFact);
31 | 			fStd += (fVal * fVal * fFact);
32 | 		}
33 | 	}
34 | 	fStd = fStd - fMean * fMean;
35 | 	//--------------------------
36 | 	x = blockIdx.y * iPadX + blockIdx.x * blockDim.x + threadIdx.x;	
37 | 	if(fStd < 0) gfImg[x] = 0.0f;
38 | 	else gfImg[x] /= (fStd + (float)1e-20);
39 | }
40 | 
41 | GNormByStd2D::GNormByStd2D(void)
42 | {
43 | }
44 | 
45 | GNormByStd2D::~GNormByStd2D(void)
46 | {
47 | }
48 | 
49 | void GNormByStd2D::DoIt(float* gfImg, int* piImgSize, bool bPadded, 
50 | 	int* piWinSize, cudaStream_t stream)
51 | {
52 | 	if(gfImg == 0L) return;
53 | 	//---------------------
54 | 	int iImageX = bPadded ? (piImgSize[0] / 2 - 1) * 2 : piImgSize[0];
55 | 	dim3 aBlockDim(512, 1);
56 | 	dim3 aGridDim( (iImageX  + aBlockDim.x - 1)/ aBlockDim.x, 
57 | 	   piImgSize[1] );
58 | 	mGNormByStd2D<<<aGridDim, aBlockDim, 0, stream>>>(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 <stdio.h>
 5 | #include <memory.h>
 6 | #include <math.h>
 7 | #include <cuda.h>
 8 | #include <cuda_runtime.h>
 9 | #include <nvToolsExt.h>
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; i<pBufferPool->m_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; i<iNumFrames; i++)
58 | 	{	mCorrectFrame(i);
59 | 	}
60 | }
61 | 
62 | void CCorrectMain::mCorrectFrame(int iFrame)
63 | {
64 | 	int iStream = iFrame % 2;
65 | 	cudaStream_t stream = m_pStreams[m_iCurGpu * 2 + iStream];
66 | 	//--------------------------------------------------------
67 | 	CBufferPool* pBufferPool = CBufferPool::GetInstance();
68 | 	CStackBuffer* pFrmBuffer = pBufferPool->GetBuffer(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<float*>(gCmpFrm);
75 | 	unsigned char* gucMap = reinterpret_cast<unsigned char*>(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 <cuda.h>
 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 <Mrcfile/CMrcFileInc.h>
 3 | #include <math.h>
 4 | #include <stdio.h>
 5 | #include <string.h>
 6 | #include <memory.h>
 7 | #include <cuda.h>
 8 | #include <cuda_runtime.h>
 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<iSize; i++)
30 | 	{	int x = i % m_aiSize[0];
31 | 		int y = i / m_aiSize[0];
32 | 		if(x == 0 || x == iEndX) pfMod[i] = -1.0f;
33 | 		else if(y == 0 || y == iEndY) pfMod[i] = -1.0f;
34 | 		else pfMod[i] = 1.0f;
35 | 	}
36 | 	//---------------------------
37 | 	mNormalize(pfMod);
38 | }
39 | 
40 | void CTemplate::mNormalize(float* pfTemplate)
41 | {
42 | 	double dMean = 0, dStd = 0;
43 | 	int iSize = m_aiSize[0] * m_aiSize[1];
44 | 	for(int i=0; i<iSize; i++)
45 | 	{	dMean += pfTemplate[i];
46 | 		dStd += (pfTemplate[i] * pfTemplate[i]);
47 | 	}
48 | 	float fMean = (float)(dMean / iSize);
49 | 	dStd = dStd / iSize - fMean * fMean;
50 | 	float fStd = (dStd <= 0) ? 0.0f : (float)sqrt(dStd);
51 | 	fStd += (float)(1e-30);
52 | 	//---------------------
53 | 	for(int i=0; i<iSize; i++)
54 | 	{	pfTemplate[i] = (pfTemplate[i] - fMean) / fStd;
55 | 	}	
56 | }
57 | 
58 | 


--------------------------------------------------------------------------------
/BadPixel/GCombineBadMap.cu:
--------------------------------------------------------------------------------
 1 | #include "CDetectMain.h"
 2 | #include <stdio.h>
 3 | #include <memory.h>
 4 | #include <math.h>
 5 | #include <cuda.h>
 6 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim>>>(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 <cuda.h>
  3 | #include <cuda_runtime.h>
  4 | #include <curand.h>
  5 | #include <memory.h>
  6 | #include <stdio.h>
  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<<<aGridDim, aBlockDim, 0, stream>>>(gfFrame, iFrameX, iPadX, 
103 | 	   gucBadMap, m_iWinSize);
104 | }
105 | 
106 | 


--------------------------------------------------------------------------------
/BadPixel/GDetectHot.cu:
--------------------------------------------------------------------------------
 1 | #include "CDetectMain.h"
 2 | #include <stdio.h>
 3 | #include <memory.h>
 4 | #include <math.h>
 5 | #include <cuda.h>
 6 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim>>>
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 <stdio.h>
  5 | #include <memory.h>
  6 | #include <math.h>
  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; y<iModSizeY; y++)
 41 | 	{	i = iOffset + y * iPadX;
 42 | 		for(x=0; x<iModSizeX; x++)
 43 | 		{	gucBadMap[i+x] = 1;
 44 | 		}
 45 | 	}
 46 | }
 47 | 
 48 | GDetectPatch::GDetectPatch(void)
 49 | {
 50 | }
 51 | 
 52 | GDetectPatch::~GDetectPatch(void)
 53 | {
 54 | }
 55 | 
 56 | void GDetectPatch::DoIt
 57 | (  	float* gfPadSum,
 58 | 	float* gfPadCC,
 59 | 	float* gfPadBuf,
 60 | 	unsigned char* pucBadMap,
 61 | 	int* piPadSize, 
 62 | 	int* piModSize,
 63 | 	float fStdThreshold
 64 | )
 65 | {	CLocalCCMap localCCMap;
 66 | 	localCCMap.DoIt(piModSize);
 67 | 	//-----------------
 68 | 	CBufferPool* pBufferPool = CBufferPool::GetInstance();
 69 | 	pBufferPool->SetDevice(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<<<aGridDim, aBlockDim>>>(gfPadCC, iImgSizeX,
 98 | 		piPadSize[0], m_fCCThreshold);
 99 | 	//------------------------------------
100 | 	// update the existing bad pixel map
101 | 	//------------------------------------
102 | 	mGUpdateBadMap<<<aGridDim, aBlockDim>>>(gfPadCC, pucBadMap,
103 | 		iImgSizeX, piPadSize[0], piModSize[0], piModSize[1]);
104 | }
105 | 
106 | 


--------------------------------------------------------------------------------
/BadPixel/GLabelPatch.cu:
--------------------------------------------------------------------------------
 1 | #include "CDetectMain.h"
 2 | #include <stdio.h>
 3 | #include <memory.h>
 4 | #include <math.h>
 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<<<aGridDim, aBlockDim>>>(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 <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <memory.h>
 5 | #include <stdio.h>
 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<giRefSize[1]; j++)
43 | 	{	for(int i=0; i<giRefSize[0]; i++)
44 | 		{	float fImg = gfSrc[j * giPadSize[0] + i];
45 | 			float fRef = gfRef[j * giRefSize[0] + i];
46 | 			//---------------------------------------
47 | 			fMean += fImg;
48 | 			fStd += (fImg * fImg);
49 | 			fCC += (fRef * fImg);
50 | 		}
51 | 	}
52 | 	int iRefSize = giRefSize[0] * giRefSize[1];
53 | 	fCC /= iRefSize;
54 | 	fMean /= iRefSize;
55 | 	fStd = fStd / iRefSize - fMean * fMean;
56 | 	if(fStd < 0) fStd = 0.0f;
57 | 	else fStd = sqrtf(fStd);
58 | 	//----------------------
59 | 	if(fStd == 0) gfPadCC[iPix] = 0.0f;
60 | 	else gfPadCC[iPix] = fabsf(fCC) / fStd;
61 | }
62 | 
63 | GLocalCC::GLocalCC(void)
64 | {
65 | }
66 | 
67 | GLocalCC::~GLocalCC(void)
68 | {
69 | }
70 | 
71 | void GLocalCC::SetRef(float* gfRef, int* piRefSize)
72 | {
73 | 	m_gfRef = gfRef;
74 | 	cudaMemcpyToSymbol(giRefSize, piRefSize, sizeof(int) * 2);
75 | }
76 | 
77 | void GLocalCC::DoIt
78 | (	float* gfPadImg, 
79 | 	int* piPadSize, 
80 | 	int iOffset,
81 | 	int iPartSize,
82 | 	float* gfPadCC,
83 | 	cudaStream_t stream
84 | )
85 | {	cudaMemcpyToSymbolAsync
86 | 	( giPadSize, piPadSize, sizeof(int) * 2, 0,
87 | 	  cudaMemcpyHostToDevice, stream );
88 | 	//---------------------------------
89 | 	dim3 aBlockDim(64, 1);
90 |         dim3 aGridDim(1, 1);
91 | 	aGridDim.x = (iPartSize + aBlockDim.x - 1) / aBlockDim.x;
92 | 	//-------------------------------------------------------
93 |         mGLocalCC<<<aGridDim, aBlockDim, 0, stream>>>
94 | 	( gfPadImg, iOffset, iPartSize, m_gfRef, gfPadCC );
95 | }
96 | 


--------------------------------------------------------------------------------
/DataUtil/CAlnSums.cpp:
--------------------------------------------------------------------------------
 1 | #include "CDataUtilInc.h"
 2 | #include "../CMainInc.h"
 3 | #include <stdio.h>
 4 | #include <string.h>
 5 | #include <memory.h>
 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 <Mrcfile/CMrcFileInc.h>
  3 | #include <memory.h>
  4 | #include <stdio.h>
  5 | #include <cuda.h>
  6 | #include <cuda_runtime.h>
  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; i<m_iBufSize; i++)
 51 | 	{	void* pvFrame = 0L;
 52 | 		pvFrame = new char[m_tFmBytes];
 53 | 		m_ppvFrames[i] = pvFrame;
 54 | 	}
 55 | }
 56 | 
 57 | void CMrcStack::Create(int iMode, int* piFmSize, int iNumFms)
 58 | {
 59 | 	int aiStkSize[] = {piFmSize[0], piFmSize[1], iNumFms};
 60 | 	this->Create(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_iBufSize; i++)
 76 | 	{	//cudaFreeHost(m_ppvFrames[i]);
 77 | 		delete[] (char*)m_ppvFrames[i];
 78 | 	}
 79 | 	if(m_ppvFrames != 0L) delete[] m_ppvFrames;
 80 | 	m_ppvFrames = 0L;
 81 | 	m_iBufSize = 0;
 82 | 	m_tFmBytes = 0;
 83 | }
 84 | 
 85 | void* CMrcStack::GetFrame(int iFrame)
 86 | {
 87 | 	if(m_ppvFrames == 0L) return 0L;
 88 | 	else if(iFrame >= m_aiStkSize[2]) return 0L;
 89 | 	//------------------------------------------
 90 | 	size_t tBytes = m_tFmBytes * iFrame;
 91 | 	char* pcFrame = reinterpret_cast<char*>(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 <tiffio.h>
 4 | #include <memory.h>
 5 | #include <unistd.h>
 6 | #include <sys/types.h>
 7 | #include <sys/stat.h>
 8 | #include <string.h>
 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<m_iNumFrames; i++) mReadFrame(i);
58 | 	}
59 | 	else
60 | 	{	int iLastFrm = m_iNumFrames - 1;
61 | 		for(int i=iLastFrm; 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<iNumStrips; i++)
89 | 	{	int iStripBytes = TIFFRawStripSize(m_pTiff, i);
90 | 		TIFFReadRawStrip(m_pTiff, i, pcEerFrm + iFrmBytes, iStripBytes);
91 | 		iFrmBytes += iStripBytes;
92 | 	}
93 | 	m_piFrmSizes[iFrame] = iFrmBytes;
94 | 	m_iBytesRead += iFrmBytes;
95 | }
96 | 
97 | 


--------------------------------------------------------------------------------
/EerUtil/CLoadEerHeader.cpp:
--------------------------------------------------------------------------------
 1 | #include "CEerUtilInc.h"
 2 | #include <cstring>
 3 | #include <unistd.h>
 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 <cuda.h>
  5 | #include <cuda_runtime.h>
  6 | #include <memory.h>
  7 | #include <stdio.h>
  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; i<pRawStack->m_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; i<pRawStack->m_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; i<iIntFmSize; i++)
 82 | 	{	int iEerFrame = iIntFmStart + i;
 83 | 		mDecodeFrame(iEerFrame, pucFrm);
 84 | 	}
 85 | }	
 86 | 
 87 | void CRenderMrcStack::mDecodeFrame
 88 | (	int iEerFrame,
 89 | 	unsigned char* pucDecodedFrm
 90 | )
 91 | {	int iEerFmBytes = m_pLoadEerFrames->GetEerFrameSize(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 <memory.h>
 3 | #include <cuda.h>
 4 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim, 0, stream>>>
38 | 	( gucFrm1, gucFrm2, gucSum, uiPixels
39 | 	);
40 | }
41 | 
42 | 


--------------------------------------------------------------------------------
/EerUtil/GDecodeEerFrame.cu:
--------------------------------------------------------------------------------
 1 | #include "CEerUtilInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <memory.h>
 5 | #include <stdio.h>
 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<<<aGridDim, aBlockDim, 0, stream>>>
74 | 		( gucEerFrame, gucZeros, gucSubpixs, iNumChunks
75 | 		);
76 | 	}
77 | 	else
78 | 	{	mGDecode8Bits<<<aGridDim, aBlockDim, 0, stream>>>
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 <math.h>
 5 | #include <stdio.h>
 6 | #include <string.h>
 7 | #include <memory.h>
 8 | #include <cuda.h>
 9 | #include <cuda_runtime.h>
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 <math.h>
 5 | #include <stdio.h>
 6 | #include <string.h>
 7 | #include <memory.h>
 8 | #include <cuda.h>
 9 | #include <cuda_runtime.h>
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 <math.h>
  3 | #include <stdio.h>
  4 | #include <string.h>
  5 | #include <memory.h>
  6 | #include <cuda.h>
  7 | #include <cuda_runtime.h>
  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 <math.h>
 5 | #include <stdio.h>
 6 | #include <string.h>
 7 | #include <memory.h>
 8 | #include <cuda.h>
 9 | #include <cuda_runtime.h>
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 <cuda.h>
 6 | #include <cufft.h>
 7 | #include <cuda_runtime.h>
 8 | #include <memory.h>
 9 | #include <stdio.h>
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 <stdio.h>
  4 | #include <memory.h>
  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; i<pCtfResults->m_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; i<pCtfResults->m_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 <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <stdio.h>
 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<<<aGridDim, aBlockDim>>>(fDefocus, fAddPhase, 
62 | 	   gfCTF1D, iCmpSize);
63 | }
64 | 


--------------------------------------------------------------------------------
/FindCtf/GRadialAvg.cu:
--------------------------------------------------------------------------------
 1 | #include "CFindCtfInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <stdio.h>
 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<iPoints; i++)
26 | 	{	float fRad = (-90.0f + i * fAngStep) * 0.017453f;
27 | 		int x = (int)(r * cosf(fRad) + 0.5f);
28 | 		int y = (int)(r * sinf(fRad) + iCmpY / 2 + 0.5f);
29 | 		fSum += gfSpectrum[y * iCmpX + x];
30 | 	}	
31 | 	gfAverage[r] = fSum / iPoints;
32 | }
33 | 
34 | GRadialAvg::GRadialAvg(void)
35 | {
36 | }
37 | 
38 | GRadialAvg::~GRadialAvg(void)
39 | {
40 | }
41 | 
42 | void GRadialAvg::DoIt
43 | (	float* gfSpect, 
44 | 	float* gfAverage,
45 | 	int* piCmpSize
46 | )
47 | {	dim3 aBlockDim(512, 1);
48 |         dim3 aGridDim(1, 1);
49 | 	aGridDim.x = (piCmpSize[0] + aBlockDim.x - 1) / aBlockDim.x;
50 |         mGRadAverage<<<aGridDim, aBlockDim>>>(gfSpect, gfAverage,
51 | 	   piCmpSize[0], piCmpSize[1]);
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/FindCtf/GRmBackground2D.cu:
--------------------------------------------------------------------------------
 1 | #include "CFindCtfInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim>>>(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 <sys/types.h>
 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 <pthread.h>
 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 <sys/time.h>
 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 <sys/types.h>
  3 | #include <sys/stat.h>
  4 | #include <unistd.h>
  5 | #include <fcntl.h>
  6 | #include <string.h>
  7 | #include <math.h>
  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<m_iNumSections; i++)
 51 | 	{	aLoadExt.DoIt(i);
 52 | 		aLoadExt.GetStage(afStage, 2);
 53 | 		float fDistX = afStage[0] - fStageX;
 54 | 		float fDistY = afStage[1] - fStageY;
 55 | 		double dDist = sqrt(fDistX * fDistX + fDistY * fDistY);
 56 | 		if(i == 0 || dMin < dDist)
 57 | 		{	dMin = dDist;
 58 | 			iSection = i;
 59 | 		}
 60 | 	}
 61 | 	//---------------------------
 62 | 	m_fDist = (float)dMin;
 63 | 	close(iFile);
 64 | 	return iSection;
 65 | }
 66 | 
 67 | int CFindMrc::FindFromShift(float fShiftX, float fShiftY)
 68 | {
 69 | 	int iFile = mOpenFile();
 70 | 	if(iFile == -1) return -1;
 71 | 	//------------------------
 72 | 	CLoadExtHeader aLoadExt;
 73 | 	aLoadExt.SetFile(iFile);
 74 | 	//----------------------
 75 | 	double dMin = 1e30;
 76 | 	int iSection;
 77 | 	float afShift[2] = {0.0f};
 78 | 	//------------------------
 79 | 	for(int i=0; i<m_iNumSections; i++)
 80 | 	{	aLoadExt.DoIt(i);
 81 | 		aLoadExt.GetShift(afShift, 2);
 82 | 		float fDistX = afShift[0] - fShiftX;
 83 | 		float fDistY = afShift[1] - fShiftY;
 84 | 		double dDist = sqrt(fDistX * fDistX + fDistY * fDistY);
 85 | 		if(i == 0 || dMin < dDist)
 86 | 		{	dMin = dDist;
 87 | 			iSection = i;
 88 | 		}
 89 | 	}
 90 | 	//---------------------------
 91 | 	m_fDist = (float)dMin;
 92 | 	close(iFile);
 93 | 	return iSection;
 94 | }
 95 | 
 96 | int CFindMrc::mOpenFile(char* pcFileName)
 97 | {
 98 | 	if(strlen(m_pcFileName) == 0) return -1;
 99 | 	else return open(m_pcFileName, O_RDWR); 
100 | }
101 | 


--------------------------------------------------------------------------------
/LibSrc/Mrcfile/App/CLoadMrc.cpp:
--------------------------------------------------------------------------------
  1 | #include "../Include/CMrcFileInc.h"
  2 | #include <Util/Util_FileName.h>
  3 | #include <Util/Util_String.h>
  4 | #include <string.h>
  5 | #include <unistd.h>
  6 | #include <fcntl.h>
  7 | #include <sys/types.h>
  8 | #include <sys/stat.h>
  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; i<iSize; i++) pcFile[i] = (char)pwcFileName[i];
 58 | 	pcFile[iSize] = 0;
 59 | 	//----------------
 60 | 	bool bOpen = this->OpenFile(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; i<iSize; i++) pcFile[i] = (char)pwcFileName[i];
 87 | 	pcFile[iSize] = 0;
 88 | 	//----------------
 89 | 	bool bOpen = this->OpenFile(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<m_iPixels; i++)
44 | 	{	int iVal = (int)(pfData[i] * m_fScale);
45 | 		if(iVal < 0) pucBuf[i] = 0;
46 | 		else if(iVal > 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<m_iPixels; i++)
55 | 	{	int iVal = (int)(pfData[i] * m_fScale);
56 | 		if(iVal > 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<m_iPixels; i++)
66 | 	{	int iVal = (int)(pfData[i] * m_fScale);
67 | 		if(iVal > 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<m_iPixels; i++)
77 | 	{	piBuf[i] = (int)(pfData[i] * m_fScale);
78 | 	}
79 | }
80 | 
81 | void CMrcScale::mToFloat(float* pfData, void* pvData)
82 | {
83 | 	float* pfBuf = (float*)pvData;
84 | 	for(int i=0; i<m_iPixels; i++)
85 | 	{	pfBuf[i] = pfData[i] * m_fScale;
86 | 	}
87 | }
88 | 


--------------------------------------------------------------------------------
/LibSrc/Mrcfile/App/CReviseExtHeader.cpp:
--------------------------------------------------------------------------------
 1 | #include "../Include/CMrcFileInc.h"
 2 | #include <Util/Util_FileName.h>
 3 | #include <memory.h>
 4 | #include <string.h>
 5 | #include <unistd.h>
 6 | #include <fcntl.h>
 7 | #include <sys/stat.h>
 8 | #include <sys/types.h>
 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; i<iSize; i++) pcFile[0] = (char)pwcFileName[i];
48 | 	pcFile[iSize] = 0;
49 | 	//----------------
50 | 	bool bOpen = this->OpenFile(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 <memory.h>
  3 | #include <unistd.h>
  4 | #include <sys/types.h>
  5 | #include <string.h>
  6 | #include <stdio.h>
  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 <Util/Util_SwapByte.h>
 3 | #include <memory.h>
 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 <memory.h>
  3 | #include <stdio.h>
  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<piRawSize[1]; y++)
 79 | 	{	unsigned char* pucSrc = pucRaw + y * piRawSize[0];
 80 | 		unsigned char* pucDst = pucPkd + y * iPkdX;
 81 | 		for(int x=0; x<piRawSize[0]; x+=2)
 82 | 		{	pucDst[x/2] = (pucSrc[x] & 0xf);
 83 | 		}
 84 | 		for(int x=1; x<piRawSize[0]; x+=2)
 85 | 		{	pucDst[x/2] += ((pucSrc[x] & 0xf) << 4);
 86 | 		}
 87 | 	}
 88 | }
 89 | 
 90 | void C4BitImage::Unpack(void* pvPkdImg, void* pvRawImg, int* piRawSize)
 91 | {
 92 | 	unsigned char* pucPkd = (unsigned char*)pvPkdImg;
 93 | 	unsigned char* pucRaw = (unsigned char*)pvRawImg;
 94 | 	int iPkdX = C4BitImage::GetPkdSize(piRawSize[0]);
 95 | 	//-----------------------------------------------
 96 | 	for(int y=0; y<piRawSize[1]; y++)
 97 | 	{	unsigned char* pucSrc = pucPkd + y * iPkdX;
 98 | 		unsigned char* pucDst = pucRaw + y * piRawSize[0];
 99 | 		for(int x=0; x<piRawSize[0]; x+=2)
100 | 		{	pucDst[x] = pucSrc[x/2] & 0xf;
101 | 		}
102 | 		for(int x=1; x<piRawSize[0]; x+=2)
103 | 		{	pucDst[x] = (pucSrc[x/2] >> 4) & 0xf;
104 | 		}
105 | 	}
106 | }
107 | 
108 | 


--------------------------------------------------------------------------------
/LibSrc/Mrcfile/Image/CSaveImage.cpp:
--------------------------------------------------------------------------------
 1 | #include "../Include/CMrcFileInc.h"
 2 | #include <memory.h>
 3 | #include <unistd.h>
 4 | #include <sys/types.h>
 5 | #include <stdio.h>
 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<iNumImgs; i++)
63 | 	{	pcImg = pcImg + tImgBytes;
64 | 		write(m_iFile, pcImg, tImgBytes);
65 | 	}
66 | }
67 | 
68 | 


--------------------------------------------------------------------------------
/LibSrc/Mrcfile/makefile:
--------------------------------------------------------------------------------
 1 | PROJ_DIR = $(shell pwd)/..
 2 | INCDIR	= $(PROJ_DIR)/Include
 3 | LIBDIR  = $(PROJ_DIR)/Lib
 4 | 
 5 | SRCS    = Header/CLoadExtHeader.cpp \
 6 | 	Header/CLoadMainHeader.cpp \
 7 | 	Header/CMainHeader.cpp \
 8 | 	Header/CSaveExtHeader.cpp \
 9 | 	Header/CSaveMainHeader.cpp \
10 | 	Image/CLoadImage.cpp \
11 | 	Image/CSaveImage.cpp \
12 | 	Image/C4BitImage.cpp \
13 | 	App/CLoadMrc.cpp \
14 | 	App/CSaveMrc.cpp \
15 | 	App/CReviseExtHeader.cpp \
16 | 	App/CMrcScale.cpp \
17 | 	App/CVerticalFlip.cpp
18 | 
19 | OBJS	= $(patsubst %.cpp, %.o, $(SRCS))
20 | OUT	= libmrcfile.a
21 | 
22 | CC = g++ -std=c++11
23 | CFLAGS	= -m64 -c -g -pthread -IInclude -I$(INCDIR)
24 | 
25 | all: $(OBJS)
26 | 	@ar rcs $(OUT) $(OBJS)
27 | 	@mv -f $(OUT) $(LIBDIR)
28 | 	@cp -f Include/*.h $(INCDIR)/Mrcfile
29 | 	@echo Static library $(OUT) has been created.
30 | 
31 | compile: $(OBJS)
32 | 	@echo Compilation has been done.
33 | 
34 | %.o: %.cpp
35 | 	@echo Compile $<
36 | 	@$(CC) $(CFLAGS) $< -o $@
37 | 
38 | clean:
39 | 	@rm -f $(OUT) $(OBJS) *.*~ makefile~
40 | 


--------------------------------------------------------------------------------
/LibSrc/Util/Util_DataFile.h:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <sys/types.h>
 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 <string.h>
  5 | #include <memory.h>
  6 | #include <stdio.h>
  7 | #include <stdlib.h>
  8 | #include <sys/statvfs.h>
  9 | #include <sys/types.h>
 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 <string.h>
 3 | #include <stdlib.h>
 4 | #include <memory.h>
 5 | #include <sys/stat.h>
 6 | #include <fcntl.h>
 7 | #include <stdio.h>
 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<iNumParentFolders; i++)
43 | 	{	char* pcParentFolder = mGetNthParentFolder(pcFolderPath, i);
44 | 		mCreateFolder(pcParentFolder);
45 | 		delete[] pcParentFolder;
46 | 	}
47 | 	mCreateFolder(pcFolderPath);
48 | }
49 | 
50 | void Util_Folder::mCreateFolder(char* pcFolder)
51 | {
52 | 	printf("Create Folder: %s\n", pcFolder);
53 | 	if(IsValid(pcFolder)) return;
54 | 	int iFile = mkdir(pcFolder, S_IRWXU | S_IRWXG);
55 | }
56 | 
57 | int Util_Folder::mFindLastSlash(char* pcFolder)
58 | {
59 | 	if(pcFolder == NULL || strlen(pcFolder) == 0) return -1;
60 | 	char* pc = strrchr(pcFolder, '/');
61 | 	if(pc == NULL) return -1;
62 | 	int iLocation = pc - pcFolder;
63 | 	return iLocation;
64 | }
65 | 
66 | int Util_Folder::mGetNumParentFolders(char* pcFolderPath)
67 | {
68 | 	int iNumParents = 0;
69 | 	char* pcParent = strchr(pcFolderPath, '/');
70 | 	while(pcParent != NULL)
71 | 	{	iNumParents++;
72 | 		pcParent = strchr(pcParent + 1, '/');
73 | 	}
74 | 	return iNumParents;
75 | }
76 | 
77 | char* Util_Folder::mGetNthParentFolder(char* pcFolderPath, int iNthParent)
78 | {
79 | 	char* pcParent = pcFolderPath;
80 | 	for(int i=0; i<=iNthParent; i++)
81 | 	{	pcParent = strchr(pcParent + 1, '/');
82 | 	}
83 | 	int iSize = pcParent - pcFolderPath;
84 | 	printf("%d  %d  %s\n", iNthParent, iSize, pcParent);
85 | 	if(pcParent == NULL) iSize = strlen(pcFolderPath);
86 | 	char* pcBuf = new char[iSize + 1];
87 | 	memset(pcBuf, 0, sizeof(char) * (iSize + 1));
88 | 	memcpy(pcBuf, pcFolderPath, sizeof(char) * iSize);
89 | 	return pcBuf;
90 | }
91 | 


--------------------------------------------------------------------------------
/LibSrc/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/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/Util/Util_Number.cpp:
--------------------------------------------------------------------------------
 1 | #include "Util_Number.h"
 2 | #include "Util_String.h"
 3 | #include <string.h>
 4 | #include <stdio.h>
 5 | #include <stdlib.h>
 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 <string.h>
 3 | #include <stdlib.h>
 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<iSize; i++)
14 | 	{	if(i == 0) 
15 | 		{	pcToken = strtok(pcString, " ");
16 | 			if(pcToken != NULL) strcpy(pcBuf, pcToken);
17 | 		}
18 | 		else 
19 | 		{	pcToken = strtok(NULL, " ");
20 | 			if(pcToken != NULL) strcat(pcBuf, pcToken);
21 | 		}
22 | 		if(pcToken == NULL) break;
23 | 	}
24 | 	strcpy(pcString, pcBuf);
25 | 	delete[] pcBuf;
26 | }
27 | 
28 | 
29 | char* Util_String::GetCopy(char* pcString)
30 | {
31 | 	if(pcString == NULL) return NULL;
32 | 	int iSize = strlen(pcString) + 1;
33 | 	char* pcCopy = new char[iSize];
34 | 	strcpy(pcCopy, pcString);
35 | 	return pcCopy;
36 | }
37 | 


--------------------------------------------------------------------------------
/LibSrc/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/Util/Util_SwapByte.cpp:
--------------------------------------------------------------------------------
 1 | #include "Util_SwapByte.h"
 2 | #include <stdint.h>
 3 | #include <memory.h>
 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 <sys/time.h>
  3 | #include <sys/types.h>
  4 | #include <errno.h>
  5 | #include <stdio.h>
  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 <pthread.h>
 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 <sys/time.h>
 3 | #include <stdio.h>
 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 <sys/time.h>
 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 <stdio.h>
  6 | #include <cufft.h>
  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 <Mrcfile/CMrcFileInc.h>
 4 | #include <memory.h>
 5 | #include <string.h>
 6 | #include <stdio.h>
 7 | #include <math.h>
 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; i<iSizeZ; i++)
60 | 	{	memset(acSerialFile, 0, sizeof(acSerialFile));
61 | 		sprintf(acSerialFile, "%s%d", pcMrcFile, i);
62 | 		bOpen = aLoadMrc.OpenFile(acSerialFile);
63 | 		if(bOpen) return true;
64 | 	}
65 | 	return false;
66 | }
67 | 
68 | void CAnalyzeMrc::GetMrcSize
69 | (	char* pcMrcFile, 
70 | 	int* piMrcSize, 
71 | 	int* piNumStacks
72 | )
73 | {	memset(piMrcSize, 0, sizeof(int) * 3);
74 | 	*piNumStacks = 0;
75 | 	//---------------
76 | 	Mrc::CLoadMrc aLoadMrc;
77 | 	if(!aLoadMrc.OpenFile(pcMrcFile)) return;
78 | 	if(!IsTomoMrc(pcMrcFile)) return;
79 | 	//-------------------------------
80 | 	piMrcSize[0] = aLoadMrc.m_pLoadMain->GetSizeX();
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 <stdio.h>
 3 | #include <memory.h>
 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 <Mrcfile/CMrcFileInc.h>
 4 | #include <memory.h>
 5 | #include <math.h>
 6 | #include <string.h>
 7 | #include <stdio.h>
 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; i<iSizeZ; i+=iStackZ)
49 | 	{	aLoadMrc.m_pLoadExt->DoIt(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 <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <memory.h>
 5 | #include <stdio.h>
 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<<<aGridDim, aBlockDim>>>(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<<<aGridDim, aBlockDim>>>(gucPkdFrm, gucRawFrm, 
84 | 	   iPackX, piRawSize[0]);
85 | }
86 | 
87 | 


--------------------------------------------------------------------------------
/MrcUtil/GAugmentRef.cu:
--------------------------------------------------------------------------------
 1 | #include "CMrcUtilInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <memory.h>
 5 | #include <stdio.h>
 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<<<aGridDim, aBlockDim>>>(gfInRef, piInSize[0], iFact,
47 | 	   gfOutRef, piOutSize[0], iOutSize);
48 | }
49 | 
50 | 


--------------------------------------------------------------------------------
/MrcUtil/GFlip2D.cu:
--------------------------------------------------------------------------------
  1 | #include "CMrcUtilInc.h"
  2 | #include <cuda.h>
  3 | #include <cuda_runtime.h>
  4 | #include <memory.h>
  5 | #include <stdio.h>
  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<<<aGridDim, aBlockDim>>>
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<<<aGridDim, aBlockDim>>>
119 | 	(  gfImg, piImgSize[0], piImgSize[1]
120 | 	);
121 | }
122 | 
123 | 


--------------------------------------------------------------------------------
/MrcUtil/GInverse2D.cu:
--------------------------------------------------------------------------------
 1 | #include "CMrcUtilInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <memory.h>
 5 | #include <stdio.h>
 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<<<aGridDim, aBlockDim>>>(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&deg; (**c**) Residual local motion measured on a micrograph acquired at 30&deg; (**d**) Residual local motion measured on a micrograph acquired at 60&deg;.
 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 <tiffio.h>
  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 <string.h>
 3 | #include <stdlib.h>
 4 | #include <memory.h>
 5 | #include <ctype.h>
 6 | #include <stdio.h>
 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 <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <string.h>
 5 | #include <stdio.h>
 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; y<piImgSize[1]; y++)
26 | 	{	float* pfSrc = pfImg + y * piImgSize[0];
27 | 		float* pfDst = pfFlip + (iEndY - y) * piImgSize[0];
28 | 		memcpy(pfDst, pfSrc, iBytes);
29 | 	}
30 | 	if(bClean) delete[] pfImg;
31 | 	//------------------------
32 | 	return pfFlip;	
33 | }
34 | 
35 | void CFlipImage::DoIt(float* pfImg, int* piImgSize)
36 | {
37 | 	if(pfImg == 0L) return;
38 | 	float* pfFlip = this->DoIt(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 <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <cufft.h>
 5 | #include <memory.h>
 6 | #include <stdio.h>
 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<float*>(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 <memory.h>
  3 | #include <stdio.h>
  4 | #include <math.h>
  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<m_iNumGroups; i++)
 95 |         {       m_piGroupSizes[i] = m_iGroupSize;
 96 |         }
 97 |         for(int i=0; i<iLeft; i++)
 98 |         {       int j = m_iNumGroups - 1 - i;
 99 |                 m_piGroupSizes[j] += 1;
100 |         }
101 | 	//-----------------------------
102 | 	m_piGroupStarts = new int[m_iNumGroups];
103 |         m_piGroupStarts[0] = 0;
104 |         for(int i=1; i<m_iNumGroups; i++)
105 |         {       m_piGroupStarts[i] = m_piGroupStarts[i-1]
106 |                   + m_piGroupSizes[i-1];
107 |         }	
108 | }
109 | 


--------------------------------------------------------------------------------
/Util/CMultiGpuBase.cpp:
--------------------------------------------------------------------------------
  1 | #include "CUtilInc.h"
  2 | #include <memory.h>
  3 | #include <stdio.h>
  4 | #include <cuda.h>
  5 | #include <cuda_runtime.h>
  6 | #include <cufft.h>
  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<m_iNumGpus; i++)
 49 | 	{	cudaSetDevice(m_piGpuIDs[i]);
 50 | 		int iStart = m_iStreamsPerGpu * i;
 51 | 		for(int j=0; j<m_iStreamsPerGpu; j++)
 52 | 		{	cudaStream_t stream = 0;
 53 | 			cudaStreamCreate(&stream);
 54 | 			m_pStreams[iStart+j] = stream;
 55 | 		}
 56 | 	}
 57 | }
 58 | 
 59 | void CMultiGpuBase::mDeleteStreams(void)
 60 | {
 61 | 	if(m_pStreams == 0L || m_piGpuIDs == 0L) return;
 62 | 	//----------------------------------------------
 63 | 	for(int i=0; i<m_iNumGpus; i++)
 64 | 	{	cudaSetDevice(m_piGpuIDs[i]);
 65 | 		int iStart = m_iStreamsPerGpu * i;
 66 | 		for(int j=0; j<m_iStreamsPerGpu; j++)
 67 | 		{	int iStream = iStart + j;
 68 | 			cudaStreamSynchronize(m_pStreams[iStream]);
 69 | 			cudaStreamDestroy(m_pStreams[iStream]);
 70 | 		}
 71 | 	}
 72 | 	//-----------------------------------------------------
 73 | 	delete[] m_pStreams;
 74 | 	m_pStreams = 0L;
 75 | }
 76 | 
 77 | void CMultiGpuBase::mCreateForwardFFTs(int* piSize, bool bPad)
 78 | {
 79 | 	if(m_iNumGpus <= 0) return;
 80 | 	//-------------------------
 81 | 	m_pForwardFFTs = new CCufft2D[m_iNumGpus];
 82 | 	for(int i=0; i<m_iNumGpus; i++)
 83 | 	{	cudaSetDevice(m_piGpuIDs[i]);
 84 | 		m_pForwardFFTs[i].CreateForwardPlan(piSize, bPad);
 85 | 	}
 86 | }
 87 | 
 88 | void CMultiGpuBase::mDeleteForwardFFTs(void)
 89 | {
 90 | 	if(m_pForwardFFTs == 0L) return;
 91 | 	for(int i=0; i<m_iNumGpus; i++)
 92 | 	{	cudaSetDevice(m_piGpuIDs[i]);
 93 | 		m_pForwardFFTs[i].DestroyPlan();
 94 | 	}
 95 | 	delete[] m_pForwardFFTs;
 96 | 	m_pForwardFFTs = 0L;
 97 | }
 98 | 
 99 | void CMultiGpuBase::mCreateInverseFFTs(int* piSize, bool bCmp)
100 | {
101 | 	if(m_iNumGpus <= 0) return;
102 | 	//-------------------------
103 | 	m_pInverseFFTs = new CCufft2D[m_iNumGpus];
104 | 	for(int i=0; i<m_iNumGpus; i++)
105 | 	{	cudaSetDevice(m_piGpuIDs[i]);
106 | 		m_pInverseFFTs[i].CreateInversePlan(piSize, bCmp);
107 | 	}
108 | }
109 | 
110 | void CMultiGpuBase::mDeleteInverseFFTs(void)
111 | {
112 | 	if(m_pInverseFFTs == 0L) return;
113 | 	for(int i=0; i<m_iNumGpus; i++)
114 | 	{	cudaSetDevice(m_piGpuIDs[i]);
115 | 		m_pInverseFFTs[i].DestroyPlan();
116 | 	}
117 | 	delete[] m_pInverseFFTs;
118 | 	m_pInverseFFTs = 0L;
119 | }
120 | 


--------------------------------------------------------------------------------
/Util/CNextItem.cpp:
--------------------------------------------------------------------------------
 1 | #include "CUtilInc.h"
 2 | #include <stdio.h>
 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 <cuda.h>
  3 | #include <cuda_runtime.h>
  4 | #include <memory.h>
  5 | #include <stdio.h>
  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; y<piImgSize[1]; y++)
 85 | 	{	float* pfSrc = pfImg + y * piImgSize[0];
 86 | 		float* pfDst = pfPad + y * iPadX;
 87 | 		cudaMemcpy(pfDst, pfSrc, iBytes, cudaMemcpyDefault);
 88 | 	}
 89 | }
 90 | 
 91 | float* CPad2D::GUnpad(float* pfPad, int* piSize)
 92 | {
 93 | 	float* gfImg = CPad2D::GGetImgBuf(piSize, false);
 94 | 	this->Unpad(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<piPadSize[1]; y++)
111 | 	{	float* pfSrc = pfPad + y * piPadSize[0];
112 | 		float* pfDst = pfImg + y * iImageX;
113 | 		cudaMemcpy(pfDst, pfSrc, iBytes, cudaMemcpyDefault);
114 | 	}
115 | }
116 | 
117 | 


--------------------------------------------------------------------------------
/Util/CParseArgs.cpp:
--------------------------------------------------------------------------------
  1 | #include "CUtilInc.h"
  2 | #include <memory.h>
  3 | #include <math.h>
  4 | #include <string.h>
  5 | #include <stdlib.h>
  6 | #include <ctype.h>
  7 | #include <stdio.h>
  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<m_argc; i++)
 30 | 	{	if(strcasecmp(m_argv[i], pcTag) != 0) continue;
 31 | 		aiRange[0] = i + 1;
 32 | 		break;
 33 | 	}
 34 | 	if(aiRange[0] == -1) return false;
 35 | 	//--------------------------------
 36 | 	char acBuf[256] = {0};
 37 | 	for(int i=aiRange[0]; i<m_argc; i++)
 38 | 	{	char* argv = m_argv[i];
 39 | 		if(argv[0] == '-' && strlen(argv) >= 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<aiRange[1]; i++)
 60 | 	{	int j = aiRange[0] + i;
 61 | 		if(j >= 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<aiRange[1]; i++)
 74 | 	{	int j = aiRange[0] + i;
 75 | 		if(j >= 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<aiRange[1]; i++)
 94 | 	{	int j = aiRange[0] + i;
 95 | 		if(j >= 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 <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <string.h>
 5 | #include <stdio.h>
 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 <Util/Util_LinEqs.h>
  3 | #include <memory.h>
  4 | #include <math.h>
  5 | #include <stdio.h>
  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<iSize; i++)
 55 | 	{	if(pbBad != 0L && pbBad[i]) continue;
 56 | 		mCalcTerms(pfX[i]);
 57 | 		if(fReg != 0.0f) mCalcCurTerms(pfX[i]);
 58 | 		for(int r=0; r<m_iDim; r++)
 59 | 		{	for(int c=0; c<m_iDim; c++)
 60 | 			{	int k = r * m_iDim + c;
 61 | 				m_pfMatrix[k] += (m_pfTerms[r] * m_pfTerms[c]
 62 | 				   + fReg * pfCurTerms[r] * pfCurTerms[c]);
 63 | 			}
 64 | 			m_pfCoeff[r] += (m_pfTerms[r] * pfY[i]);
 65 | 		}
 66 | 	}
 67 | 	//-----------------------------------------------------
 68 | 	Util_LinEqs aLinEqs;
 69 | 	bool bSuccess = aLinEqs.DoIt(m_pfMatrix, m_pfCoeff, m_iDim);
 70 | 	if(!bSuccess) return false;
 71 | 	//-------------------------
 72 | 	for(int i=0; i<iSize; i++)
 73 | 	{	pfFit[i] = mCalcFit(pfX[i]);
 74 | 	}
 75 | 	return true;
 76 | }
 77 | 
 78 | float CSplineFit1D::mCalcFit(float fX)
 79 | {
 80 | 	mCalcTerms(fX);
 81 | 	float fFitVal = 0.0f;
 82 | 	for(int i=0; i<m_iDim; i++)
 83 | 	{	fFitVal += m_pfCoeff[i] * m_pfTerms[i];
 84 | 	}
 85 | 	return fFitVal;
 86 | }
 87 | 
 88 | void CSplineFit1D::mCalcTerms(float fX)
 89 | {
 90 | 	m_pfTerms[0] = 1;
 91 | 	for(int i=1; i<3; i++)
 92 | 	{	m_pfTerms[i] = m_pfTerms[i-1] * fX;
 93 | 	}
 94 | 	//-----------------------------------------
 95 | 	memset(m_pfTerms+3, 0, sizeof(float) * m_iNumKnots);	
 96 | 	for(int i=0; i<m_iNumKnots; i++)
 97 | 	{	if(fX < m_pfKnots[i]) break;
 98 | 		float fVal = fX - m_pfKnots[i];
 99 | 		m_pfTerms[i+3] = fVal * fVal;
100 | 	}
101 | }
102 | 
103 | void CSplineFit1D::mCalcCurTerms(float fX)
104 | {
105 | 	float* pfCurTerms = m_pfTerms + m_iDim;
106 | 	memset(pfCurTerms, 0, sizeof(float) * m_iDim);
107 | 	//--------------------------------------------
108 | 	pfCurTerms[1] = 1.0f;
109 | 	pfCurTerms[2] = 2.0f * fX;
110 | 	for(int i=0; i<m_iNumKnots; i++)
111 | 	{	float fVal = fX - m_pfKnots[i];
112 | 		if(fVal > 0) break;
113 | 		pfCurTerms[i+3] = 2.0f * fVal;
114 | 	}
115 | }
116 | 		
117 | 		
118 | 
119 | 


--------------------------------------------------------------------------------
/Util/GAddFrames.cu:
--------------------------------------------------------------------------------
  1 | #include "CUtilInc.h"
  2 | #include <memory.h>
  3 | #include <cuda.h>
  4 | #include <cuda_runtime.h>
  5 | #include <cufft.h>
  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<<<aGridDim, aBlockDim, 0, stream>>>
 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<<<aGridDim, aBlockDim, 0, stream>>>
 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<<<aGridDim, aBlockDim, 0, stream>>>(gucFrm1,
100 | 	   gucFrm2, gucSum, nxy);
101 | }
102 | 


--------------------------------------------------------------------------------
/Util/GCorrLinearInterp.cu:
--------------------------------------------------------------------------------
 1 | #include "CUtilInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim, 0, stream>>>(gCmpFrm, piCmpSize[1]);
45 | }
46 | 
47 | 


--------------------------------------------------------------------------------
/Util/GFFT1D.cu:
--------------------------------------------------------------------------------
 1 | #include "CUtilInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 4 | #include <memory.h>
 5 | #include <math.h>
 6 | #include <stdio.h>
 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<<<aGridDim, aBlockDim>>>
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 <cuda.h>
 3 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim, 0, stream>>>
47 | 	( gfImg, piSize[0], iSizeY, fMean, fStd
48 | 	);
49 | }
50 | 
51 | 


--------------------------------------------------------------------------------
/Util/GPad2D.cu:
--------------------------------------------------------------------------------
 1 | #include "CUtilInc.h"
 2 | #include <memory.h>
 3 | #include <cuda.h>
 4 | #include <cuda_runtime.h>
 5 | #include <cufft.h>
 6 | 
 7 | using namespace MotionCor2::Util;
 8 | 
 9 | template <typename T>
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 <typename T>
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<<<aGridDim,aBlockDim, 0, stream>>>(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<<<aGridDim, aBlockDim, 0, stream>>>(gfPadImg, 
51 | 		iImgSizeX, gfImg);
52 | }
53 | 


--------------------------------------------------------------------------------
/Util/GPartialCopy.cu:
--------------------------------------------------------------------------------
 1 | #include "CUtilInc.h"
 2 | #include <memory.h>
 3 | #include <cuda.h>
 4 | #include <cuda_runtime.h>
 5 | #include <cufft.h>
 6 | 
 7 | using namespace MotionCor2::Util;
 8 | 
 9 | template <typename T>
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<<<aGridDim, aBlockDim, 0, stream>>>
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<<<aGridDim, aBlockDim, 0, stream>>>
50 | 	( pSrc, iSrcSizeX, pDst, iCpySizeX, piDstSize[0] );
51 | }
52 | 
53 | 


--------------------------------------------------------------------------------
/Util/GPhaseShift2D.cu:
--------------------------------------------------------------------------------
 1 | #include "CUtilInc.h"
 2 | #include "../MrcUtil/CMrcUtilInc.h"
 3 | #include <cuda.h>
 4 | #include <cuda_runtime.h>
 5 | #include <stdio.h>
 6 | #include <math.h>
 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<<<aGridDim, aBlockDim, 0, stream>>>(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 <cuda.h>
 3 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim, 0, stream>>>(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<<<aGridDim, aBlockDim, 0, stream>>>(gfImg, iPixels, fVal);	
49 | }
50 | 


--------------------------------------------------------------------------------
/Util/GRoundEdge.cu:
--------------------------------------------------------------------------------
 1 | #include "CUtilInc.h"
 2 | #include <cuda.h>
 3 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim>>>(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 <cuda.h>
 3 | #include <cuda_runtime.h>
 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<<<aGridDim, aBlockDim>>>(gfImg, fMin, fMax,
41 | 	   piImgSize[0], piImgSize[1]);
42 | }
43 | 


--------------------------------------------------------------------------------
/docs/ReadmeImg.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/czimaginginstitute/MotionCor3/f2cc4b1772f140fb44741502d4102a0e9f248ed2/docs/ReadmeImg.png


--------------------------------------------------------------------------------