def loadPupilFitC():
pupil_fit = loadclib.loadCLibrary("pupil_fit")
# From sa_library/multi_fit.c
pupil_fit.mFitGetFitImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
pupil_fit.mFitGetNError.argtypes = [ctypes.c_void_p]
pupil_fit.mFitGetNError.restype = ctypes.c_int
pupil_fit.mFitGetPeakPropertyDouble.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p]
pupil_fit.mFitGetPeakPropertyInt.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32),
ctypes.c_char_p]
pupil_fit.mFitGetResidual.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
pupil_fit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
pupil_fit.mFitGetUnconverged.restype = ctypes.c_int
pupil_fit.mFitIterateLM.argtypes = [ctypes.c_void_p]
pupil_fit.mFitNewBackground.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
pupil_fit.mFitNewImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
pupil_fit.mFitRemoveErrorPeaks.argtypes = [ctypes.c_void_p]
pupil_fit.mFitRemoveRunningPeaks.argtypes = [ctypes.c_void_p]
pupil_fit.mFitSetPeakStatus.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32)]
# From pupilfn/pupil_fit.c
pupil_fit.pfitCleanup.argtypes = [ctypes.c_void_p]
pupil_fit.pfitInitialize.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
pupil_fit.pfitInitialize.restype = ctypes.POINTER(daoFitC.fitData)
pupil_fit.pfitNewPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p,
ctypes.c_int]
pupil_fit.pfitSetZRange.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
return pupil_fit
def setCInterface(homotopy_ia_lib):
global homotopyIa
homotopyIa = loadclib.loadCLibrary(os.path.dirname(__file__),
homotopy_ia_lib)
# Check that C libraries were compiled as expected.
l1flt_size = homotopyIa.getL1FLTSize()
if (l1flt_size != 8):
print("L1FLT is not of type double, exiting")
exit()
homotopyIa.analyzeImage.argtypes = [
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64)
]
homotopyIa.getPeaks.argtypes = [
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.int32), c_int
]
homotopyIa.getPeaks.restype = c_int
homotopyIa.openFile.argtypes = [c_char_p]
homotopyIa.openFile.restype = c_int
homotopyIa.saveHighRes.argtypes = [ndpointer(dtype=numpy.float64), c_int]
homotopyIa.saveHighRes.restype = c_int
homotopyIa.setImageParameters.argtypes = [
ndpointer(dtype=numpy.float64), c_int, c_int, c_int, c_double, c_int,
c_int, c_int, c_int, c_int
]
def setCInterface(homotopy_lib):
global homotopy
homotopy = loadclib.loadCLibrary(homotopy_lib)
l1flt_size = homotopy.getL1FLTSize()
if(l1flt_size == 4):
float_type = c_float
float_array_type = numpy.float32
elif(l1flt_size == 8):
float_type = c_double
float_array_type = numpy.float64
homotopy.getXVector.argtypes = [ndpointer(dtype=float_array_type)]
homotopy.initialize.argtypes = [ndpointer(dtype=float_array_type),
c_int,
c_int,
c_int,
c_int,
c_int]
homotopy.l2Error.argtypes = [ndpointer(dtype=float_array_type)]
homotopy.l2Error.restype = float_type
homotopy.newYVector.argtypes = [ndpointer(dtype=float_array_type)]
homotopy.solve.argtypes = [float_type, c_int]
homotopy.solve.restype = float_type
if(hasattr(homotopy, "getVisited")):
homotopy.getVisited.argtypes = [ndpointer(dtype=numpy.int32)]
if(hasattr(homotopy, "initializeGPU")):
homotopy.initializeGPU.argtypes = [c_char_p,
c_int,
c_int,
c_int]
def loadMPFitCArb():
mp_fit = loadclib.loadCLibrary("mp_fit_arb")
# From multi_plane/mp_fit_arb.c
mp_fit.mpArbInitializePSFFFTChannel.argtypes = [ctypes.c_void_p,
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_int]
mp_fit.mpArbInitializePupilFnChannel.argtypes = [ctypes.c_void_p,
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_double,
ctypes.c_int]
mp_fit.mpArbInitializeSplineChannel.argtypes = [ctypes.c_void_p,
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_int]
mp_fit.mpArbNewPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p,
ctypes.c_int]
return mp_fit
def setCInterface(homotopy_ia_lib):
global homotopyIa
homotopyIa = loadclib.loadCLibrary(homotopy_ia_lib)
# Check that C libraries were compiled as expected.
l1flt_size = homotopyIa.getL1FLTSize()
if(l1flt_size != 8):
print("L1FLT is not of type double, exiting")
exit()
homotopyIa.analyzeImage.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64)]
homotopyIa.getPeaks.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.int32),
c_int]
homotopyIa.getPeaks.restype = c_int
homotopyIa.openFile.argtypes = [c_char_p]
homotopyIa.openFile.restype = c_int
homotopyIa.saveHighRes.argtypes = [ndpointer(dtype=numpy.float64),
c_int]
homotopyIa.saveHighRes.restype = c_int
homotopyIa.setImageParameters.argtypes = [ndpointer(dtype=numpy.float64),
c_int,
c_int,
c_int,
c_double,
c_int,
c_int,
c_int,
c_int,
c_int]
def setCInterface(homotopy_lib):
global homotopy
homotopy = loadclib.loadCLibrary("storm_analysis.L1H", homotopy_lib)
l1flt_size = homotopy.getL1FLTSize()
if (l1flt_size == 4):
float_type = c_float
float_array_type = numpy.float32
elif (l1flt_size == 8):
float_type = c_double
float_array_type = numpy.float64
homotopy.getXVector.argtypes = [ndpointer(dtype=float_array_type)]
homotopy.initialize.argtypes = [
ndpointer(dtype=float_array_type), c_int, c_int, c_int, c_int, c_int
]
homotopy.l2Error.argtypes = [ndpointer(dtype=float_array_type)]
homotopy.l2Error.restype = float_type
homotopy.newYVector.argtypes = [ndpointer(dtype=float_array_type)]
homotopy.solve.argtypes = [float_type, c_int]
homotopy.solve.restype = float_type
if (hasattr(homotopy, "getVisited")):
homotopy.getVisited.argtypes = [ndpointer(dtype=numpy.int32)]
if (hasattr(homotopy, "initializeGPU")):
homotopy.initializeGPU.argtypes = [c_char_p, c_int, c_int, c_int]
def loadFFTFitC():
fft_fit = loadclib.loadCLibrary("storm_analysis.pupilfn", "fft_fit")
# From sa_library/multi_fit.c
fft_fit.mFitGetFitImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
fft_fit.mFitGetNError.argtypes = [ctypes.c_void_p]
fft_fit.mFitGetNError.restype = ctypes.c_int
fft_fit.mFitGetPeakPropertyDouble.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p]
fft_fit.mFitGetPeakPropertyInt.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32),
ctypes.c_char_p]
fft_fit.mFitGetResidual.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
fft_fit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
fft_fit.mFitGetUnconverged.restype = ctypes.c_int
fft_fit.mFitIterateLM.argtypes = [ctypes.c_void_p]
fft_fit.mFitIterateOriginal.argtypes = [ctypes.c_void_p]
fft_fit.mFitNewBackground.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
fft_fit.mFitNewImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
fft_fit.mFitRemoveErrorPeaks.argtypes = [ctypes.c_void_p]
fft_fit.mFitRemoveRunningPeaks.argtypes = [ctypes.c_void_p]
fft_fit.mFitSetPeakStatus.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32)]
# From psf_fft/fft_fit.c
fft_fit.ftFitCleanup.argtypes = [ctypes.c_void_p]
fft_fit.ftFitInitialize.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
fft_fit.ftFitInitialize.restype = ctypes.POINTER(daoFitC.fitData)
fft_fit.ftFitNewPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p,
ctypes.c_int]
return fft_fit
def loadCubicFitC():
cubic_fit = loadclib.loadCLibrary("storm_analysis.spliner", "cubic_fit")
# From sa_library/multi_fit.c
cubic_fit.mFitGetResidual.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
cubic_fit.mFitGetResults.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
cubic_fit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
cubic_fit.mFitGetUnconverged.restype = ctypes.c_int
cubic_fit.mFitNewImage.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
# From spliner/cubic_spline.c
cubic_fit.getZSize.argtypes = [ctypes.c_void_p]
cubic_fit.getZSize.restype = ctypes.c_int
cubic_fit.initSpline2D.argtypes = [
ndpointer(dtype=numpy.float64), ctypes.c_int, ctypes.c_int
]
cubic_fit.initSpline2D.restype = ctypes.c_void_p
cubic_fit.initSpline3D.argtypes = [
ndpointer(dtype=numpy.float64), ctypes.c_int, ctypes.c_int,
ctypes.c_int
]
cubic_fit.initSpline3D.restype = ctypes.c_void_p
# From spliner/cubic_fit.c
cubic_fit.cfCleanup.argtypes = [ctypes.c_void_p]
cubic_fit.cfInitialize.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64), ctypes.c_double, ctypes.c_int,
ctypes.c_int
]
cubic_fit.cfInitialize.restype = ctypes.c_void_p
cubic_fit.cfIterateSpline.argtypes = [ctypes.c_void_p]
cubic_fit.cfNewPeaks.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64), ctypes.c_int
]
return cubic_fit
def loadCubicFitC():
cubic_fit = loadclib.loadCLibrary("storm_analysis.spliner", "cubic_fit")
# C interface definition.
cubic_fit.mFitGetResidual.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
cubic_fit.mFitGetResults.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
cubic_fit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
cubic_fit.mFitGetUnconverged.restype = ctypes.c_int
cubic_fit.cleanup.argtypes = [ctypes.c_void_p]
cubic_fit.getZSize.argtypes = [ctypes.c_void_p]
cubic_fit.getZSize.restype = ctypes.c_int
cubic_fit.initialize.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
cubic_fit.initialize.restype = ctypes.c_void_p
cubic_fit.initSpline2D.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_int,
ctypes.c_int]
cubic_fit.initSpline2D.restype = ctypes.c_void_p
cubic_fit.initSpline3D.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_int,
ctypes.c_int,
ctypes.c_int]
cubic_fit.initSpline3D.restype = ctypes.c_void_p
cubic_fit.iterateSpline.argtypes = [ctypes.c_void_p]
cubic_fit.mFitNewImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
cubic_fit.newPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_int]
return cubic_fit
def loadDaoFitC():
daofit = loadclib.loadCLibrary("storm_analysis.sa_library", "dao_fit")
# C interface definition
daofit.mFitGetResidual.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
daofit.mFitGetResults.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
daofit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
daofit.mFitGetUnconverged.restype = ctypes.c_int
daofit.cleanup.argtypes = [ctypes.c_void_p]
daofit.initialize.argtypes = [
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64), ctypes.c_double, ctypes.c_int,
ctypes.c_int
]
daofit.initialize.restype = ctypes.c_void_p
daofit.initializeZParameters.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64), ctypes.c_double, ctypes.c_double
]
daofit.iterate2DFixed.argtypes = [ctypes.c_void_p]
daofit.iterate2D.argtypes = [ctypes.c_void_p]
daofit.iterate3D.argtypes = [ctypes.c_void_p]
daofit.iterateZ.argtypes = [ctypes.c_void_p]
daofit.mFitNewImage.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
daofit.newPeaks.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64), ctypes.c_int
]
return daofit
def loadMPFitCDao():
mp_fit = loadclib.loadCLibrary("storm_analysis.multi_plane", "mp_fit_dao")
# From multi_plane/mp_fit_dao.c
mp_fit.mpDaoInitialize2DChannel.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64), ctypes.c_double, ctypes.c_double,
ctypes.c_int, ctypes.c_int
]
mp_fit.mpDaoNewPeaks.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64), ctypes.c_char_p, ctypes.c_int
]
return mp_fit
def loadDaoFitC():
daofit = loadclib.loadCLibrary("storm_analysis.sa_library", "dao_fit")
# C interface definition
daofit.mFitGetResidual.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitGetResults.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
daofit.mFitGetUnconverged.restype = ctypes.c_int
daofit.cleanup.argtypes = [ctypes.c_void_p]
daofit.initialize.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
daofit.initialize.restype = ctypes.c_void_p
daofit.initializeZParameters.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_double]
daofit.iterate2DFixed.argtypes = [ctypes.c_void_p]
daofit.iterate2D.argtypes = [ctypes.c_void_p]
daofit.iterate3D.argtypes = [ctypes.c_void_p]
daofit.iterateZ.argtypes = [ctypes.c_void_p]
daofit.mFitNewImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.newPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_int]
return daofit
def loadMPFitCDao():
mp_fit = loadclib.loadCLibrary("mp_fit_dao")
# From multi_plane/mp_fit_dao.c
mp_fit.mpDaoInitialize2DChannel.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
mp_fit.mpDaoNewPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p,
ctypes.c_int]
return mp_fit
#!/usr/bin/env python
"""
Simple Python interface to psf_fft.c
Hazen 10/17
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
psf_fft = loadclib.loadCLibrary("storm_analysis.psf_ftt", "psf_fft")
psf_fft.pFTCleanup.argtypes = [ctypes.c_void_p]
psf_fft.pFTGetPSF.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
psf_fft.pFTGetPSFdx.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
psf_fft.pFTGetPSFdy.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
psf_fft.pFTGetPSFdz.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
psf_fft.pFTInitialize.argtypes = [ndpointer(dtype = numpy.float64),
#!/usr/bin/env python
"""
Python interface to the C apply_drift_correction library.
Hazen 10/16
"""
import ctypes
import os
from storm_analysis import asciiString
import storm_analysis.sa_library.loadclib as loadclib
adc = loadclib.loadCLibrary("storm_analysis.sa_utilities",
"apply-drift-correction")
adc.applyDriftCorrection.argtypes = [ctypes.c_int, ctypes.c_void_p]
def applyDriftCorrection(mlist_filename, drift_filename):
argc = 3
argv = (ctypes.c_char_p * argc)()
argv[:] = [
asciiString(elt)
for elt in ["apply-drift-correction", mlist_filename, drift_filename]
]
adc.applyDriftCorrection(argc, argv)
if (__name__ == "__main__"):
import sys
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import random
import sys
import storm_analysis.spliner.spline2D as spline2D
import storm_analysis.spliner.spline3D as spline3D
import storm_analysis.sa_library.loadclib as loadclib
# Load the library.
cubic = loadclib.loadCLibrary("cubic_spline")
# C interface definition.
cubic.computeDelta2D.argtypes = [
ctypes.c_void_p, ctypes.c_double, ctypes.c_double
]
cubic.computeDelta3D.argtypes = [
ctypes.c_void_p, ctypes.c_double, ctypes.c_double, ctypes.c_double
]
cubic.dxfSpline2D.argtypes = [
ctypes.c_void_p, ctypes.c_double, ctypes.c_double
]
cubic.dxfSpline2D.restype = ctypes.c_double
Note that because the widths in x/y are transposed in the HDF5
format relative to the Insight3 bin format you may need to
update your calibration parameters.
Hazen 1/18
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.sa_h5py as saH5Py
c_fitz = loadclib.loadCLibrary("storm_analysis.sa_utilities", "fitz")
c_fitz.cleanup.argtypes = [ctypes.c_void_p]
c_fitz.initialize.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_double,
ctypes.c_double,
ctypes.c_double]
c_fitz.initialize.restype = ctypes.c_void_p
c_fitz.findBestZ.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
c_fitz.findBestZ.restype = ctypes.c_double
def loadCubicFitC():
cubic_fit = loadclib.loadCLibrary("cubic_fit")
# From sa_library/multi_fit.c
cubic_fit.mFitGetFitImage.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
cubic_fit.mFitGetNError.argtypes = [ctypes.c_void_p]
cubic_fit.mFitGetNError.restype = ctypes.c_int
cubic_fit.mFitGetPeakPropertyDouble.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64), ctypes.c_char_p
]
cubic_fit.mFitGetPeakPropertyInt.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.int32), ctypes.c_char_p
]
cubic_fit.mFitGetResidual.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
cubic_fit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
cubic_fit.mFitGetUnconverged.restype = ctypes.c_int
cubic_fit.mFitIterateLM.argtypes = [ctypes.c_void_p]
cubic_fit.mFitIterateOriginal.argtypes = [ctypes.c_void_p]
cubic_fit.mFitNewBackground.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
cubic_fit.mFitNewImage.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64), ctypes.c_int
]
cubic_fit.mFitRemoveErrorPeaks.argtypes = [ctypes.c_void_p]
cubic_fit.mFitRemoveRunningPeaks.argtypes = [ctypes.c_void_p]
cubic_fit.mFitSetPeakStatus.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.int32)
]
# From spliner/cubic_spline.c
cubic_fit.getZSize.argtypes = [ctypes.c_void_p]
cubic_fit.getZSize.restype = ctypes.c_int
cubic_fit.initSpline2D.argtypes = [
ndpointer(dtype=numpy.float64), ctypes.c_int, ctypes.c_int
]
cubic_fit.initSpline2D.restype = ctypes.c_void_p
cubic_fit.initSpline3D.argtypes = [
ndpointer(dtype=numpy.float64), ctypes.c_int, ctypes.c_int,
ctypes.c_int
]
cubic_fit.initSpline3D.restype = ctypes.c_void_p
# From spliner/cubic_fit.c
cubic_fit.cfCleanup.argtypes = [ctypes.c_void_p]
cubic_fit.cfInitialize.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64), ctypes.c_double, ctypes.c_int,
ctypes.c_int
]
cubic_fit.cfInitialize.restype = ctypes.POINTER(daoFitC.fitData)
cubic_fit.cfInitialize2D.argtypes = [ctypes.c_void_p]
cubic_fit.cfInitialize3D.argtypes = [ctypes.c_void_p, ctypes.c_int]
cubic_fit.cfNewPeaks.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64), ctypes.c_char_p, ctypes.c_int
]
return cubic_fit
"""
Python interface to ADMM Lasso C library.
Hazen 11/19
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import storm_analysis.sa_library.cs_algorithm as csAlgorithm
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
import storm_analysis.admm.admm_math as admmMath
admm_lasso = loadclib.loadCLibrary("admm_lasso")
# C interface definition.
admm_lasso.getAx.argtypes = [ctypes.c_void_p, ndpointer(dtype=numpy.float64)]
admm_lasso.getXVector.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
admm_lasso.initialize2D.argtypes = [
ctypes.c_double, ctypes.c_int, ctypes.c_int
]
admm_lasso.initialize2D.restype = ctypes.c_void_p
admm_lasso.initialize3D.argtypes = [
ctypes.c_double, ctypes.c_int, ctypes.c_int, ctypes.c_int
#!/usr/bin/env python
"""
Python interface to the C avemlist library.
Hazen 10/16
"""
import ctypes
import os
from storm_analysis import asciiString
import storm_analysis.sa_library.loadclib as loadclib
c_avemlist = loadclib.loadCLibrary("storm_analysis.sa_utilities", "avemlist")
c_avemlist.avemlist.argtypes = [ctypes.c_int, ctypes.c_void_p]
def avemlist(input_filename, output_filename):
argc = 3
argv = (ctypes.c_char_p * argc)()
argv[:] = [
asciiString(elt)
for elt in ["avemlist", input_filename, output_filename]
]
c_avemlist.avemlist(argc, argv)
if (__name__ == "__main__"):
import sys
# Simple Python interface to grid.c. This is a somewhat faster
# but less flexible approach to creating 2D and 3D histograms
# than using the built-in numpy function numpy.histogramdd().
#
# Hazen 12/11
#
from ctypes import *
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
grid = loadclib.loadCLibrary("storm_analysis.sa_library", "grid")
# Function specifications
grid.grid2D.argtypes = [ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
c_int,
c_int,
c_int]
grid.grid3D.argtypes = [ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
c_int,
c_int,
#
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import random
import sys
import storm_analysis.spliner.spline2D as spline2D
import storm_analysis.spliner.spline3D as spline3D
import storm_analysis.sa_library.loadclib as loadclib
# Load the library.
cubic = loadclib.loadCLibrary("storm_analysis.spliner", "cubic_spline")
# C interface definition.
cubic.computeDelta2D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
cubic.computeDelta3D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double,
ctypes.c_double]
cubic.dxfSpline2D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
cubic.dxfSpline2D.restype = ctypes.c_double
#!/usr/bin/env python
"""
Simple Python interface to matched_filter.c
Hazen 3/16
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
m_filter = loadclib.loadCLibrary("matched_filter")
m_filter.cleanup.argtypes = [ctypes.c_void_p]
m_filter.convolve.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64)
]
m_filter.convolveMemo.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64)
]
import numpy
import os
import scipy
import scipy.ndimage.filters
import sys
from numpy.ctypeslib import ndpointer, as_ctypes
import storm_analysis.sa_library.loadclib as loadclib
# define useful pointers
c_int_p = POINTER(c_int)
c_double_p = POINTER(c_double)
# Load mlem C library
mlem = loadclib.loadCLibrary("_mlem_sparse")
# Define structures
class GAUSS(Structure):
_fields_ = [("half_x_size", c_int),
("half_y_size", c_int),
("x_size", c_int),
("y_size", c_int),
("xc", c_double),
("yc", c_double),
("zc", c_double),
("width_x", c_double),
("width_y", c_double),
("coeff", c_double_p)]
class PSF(Structure):
Simple Python interface to grid.c. This is a somewhat faster
but less flexible approach to creating 2D and 3D histograms
than using the built-in numpy function numpy.histogramdd().
Hazen 12/11
"""
from ctypes import *
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
grid = loadclib.loadCLibrary("grid")
# Function specifications
grid.grid2D.argtypes = [ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
c_int,
c_int,
c_int]
grid.grid3D.argtypes = [ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
c_int,
c_int,
import numpy
import os
import scipy
import scipy.ndimage.filters
import sys
from numpy.ctypeslib import ndpointer, as_ctypes
import storm_analysis.sa_library.loadclib as loadclib
# define useful pointers
c_int_p = POINTER(c_int)
c_double_p = POINTER(c_double)
# Load mlem C library
mlem = loadclib.loadCLibrary("storm_analysis.decon_storm", "_mlem_sparse")
# Define structures
class GAUSS(Structure):
_fields_ = [("half_x_size", c_int),
("half_y_size", c_int),
("x_size", c_int),
("y_size", c_int),
("xc", c_double),
("yc", c_double),
("zc", c_double),
("width_x", c_double),
("width_y", c_double),
("coeff", c_double_p)]
class PSF(Structure):
# Simple Python interface to fista_lib C library.
#
# Hazen 07/13
#
#
from ctypes import *
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
fista = loadclib.loadCLibrary("storm_analysis.L1H", "_fista_lib")
# C interface definition.
fista.getXVector.argtypes = [ndpointer(dtype=numpy.float64)]
fista.initialize.argtypes = [ndpointer(dtype=numpy.float64),
c_int,
c_int,
c_int]
fista.iterateFISTA.argtypes = [c_double,
c_double,
c_int]
fista.iterateFISTAToL0Target.argtypes = [c_double,
c_double,
c_int]
fista.iterateFISTAToL0Target.restype = c_int
fista.iterateISTA.argtypes = [c_double,
# multi_fit.c
#
# FIXME: Don't just import all of ctypes.
#
from ctypes import *
import math
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.ia_utilities_c as util_c
import storm_analysis.sa_library.loadclib as loadclib
multi = loadclib.loadCLibrary(os.path.dirname(__file__), "multi_fit")
# C interface definition
multi.getError.restype = c_double
multi.getResidual.argtypes = [ndpointer(dtype=numpy.float64)]
multi.getResults.argtypes = [ndpointer(dtype=numpy.float64)]
multi.getUnconverged.restype = c_int
multi.initialize.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
c_double,
c_int,
c_int,
c_int,
c_int]
multi.initializeZParameters.argtypes = [ndpointer(dtype=numpy.float64),
#!/usr/bin/env python
"""
Python interface for affine_transform.c
Hazen 5/17
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
a_trans = loadclib.loadCLibrary("affine_transform")
a_trans.cleanup.argtypes = [ctypes.c_void_p]
a_trans.transform.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64),
ctypes.c_int,
ctypes.c_int]
a_trans.initialize.argtypes = [ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
a_trans.initialize.restype = ctypes.c_void_p
class AffineTransform(object):
def __init__(self, xt = None, yt = None, **kwds):
"""
# Hazen 01/14
#
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.ia_utilities_c as utilC
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.spliner.spline2D as spline2D
import storm_analysis.spliner.spline3D as spline3D
# Load the library.
cubic_fit = loadclib.loadCLibrary(os.path.dirname(__file__), "cubic_fit")
# C interface definition.
cubic_fit.fSpline2D.argtypes = [ctypes.c_double, ctypes.c_double]
cubic_fit.fSpline2D.restype = ctypes.c_double
cubic_fit.fSpline3D.argtypes = [
ctypes.c_double, ctypes.c_double, ctypes.c_double
]
cubic_fit.fSpline3D.restype = ctypes.c_double
cubic_fit.getResidual.argtypes = [ndpointer(dtype=numpy.float64)]
cubic_fit.getResults.argtypes = [ndpointer(dtype=numpy.float64)]
# Python interface to dbscan.so library.
#
# Hazen
#
#
import ctypes
import math
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
lib_dbscan = loadclib.loadCLibrary("storm_analysis.dbscan", "dbscan")
lib_dbscan.dbscan.argtypes = [ndpointer(dtype=numpy.float32),
ndpointer(dtype=numpy.float32),
ndpointer(dtype=numpy.float32),
ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ctypes.c_int,
ctypes.c_float,
ctypes.c_int,
ctypes.c_int]
lib_dbscan.locClSize.argtypes = [ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ctypes.c_int,
ctypes.c_int]
#!/usr/bin/env python
"""
Simple Python interface to matched_filter.c
Hazen 3/16
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
m_filter = loadclib.loadCLibrary("matched_filter")
m_filter.cleanup.argtypes = [ctypes.c_void_p]
m_filter.convolve.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
m_filter.convolveMemo.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
m_filter.initialize.argtypes = [ndpointer(dtype = numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int,
#!/usr/bin/env python
"""
Draws guassians onto a user supplied image.
Hazen 01/16
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
drawgauss = loadclib.loadCLibrary("storm_analysis.simulator", "draw_gaussians")
drawgauss.drawGaussians.argtypes = [
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64), ctypes.c_int, ctypes.c_int, ctypes.c_int,
ctypes.c_int
]
def cDrawGaussians(image, objects, resolution):
"""
Draws Gaussian's on image inplace at the requested resolution.
image - A 2D C contiguous numpy.float64 array.
objects - (N,5) numpy array, [[x1,y1,h1,sx1,sy1], [x2,y2,h2,sx2,sy2], ..]
resolution - Number of sub-pixels in X/Y to sample over.
#!/usr/bin/env python
"""
Simple Python interface to frc.c.
Hazen 10/14
"""
from ctypes import *
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
frc_lib = loadclib.loadCLibrary("frc")
# Function specifications.
frc_lib.calc_frc.argtypes = [ndpointer(dtype=numpy.complex128),
ndpointer(dtype=numpy.complex128),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.int32),
c_int,
c_int]
def frc(fft1, fft2):
"""
Calculate FRC (this assumes that the images are square.
"""
y_size = fft1.shape[0]
#!/usr/bin/env python
"""
Simple Python interface to fista_decon_utilities.c
Hazen 1/16
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
fd_util = loadclib.loadCLibrary("storm_analysis.fista", "fista_decon_utilities")
# C interface definition
fd_util.label.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.int32),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int]
fd_util.label.restype = ctypes.c_int
fd_util.moments.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.int32),
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
#!/usr/bin/env python
"""
Simple Python interface to matched_filter.c
Hazen 3/16
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
m_filter = loadclib.loadCLibrary("storm_analysis.sa_library", "matched_filter")
m_filter.cleanup.argtypes = [ctypes.c_void_p]
m_filter.convolve.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
m_filter.convolveMemo.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
m_filter.initialize.argtypes = [ndpointer(dtype = numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int,
#!/usr/bin/env python
#
# Simply Python interface to matched_filter.c
#
# Hazen 3/16
#
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
m_filter = loadclib.loadCLibrary(os.path.dirname(__file__), "matched_filter")
m_filter.cleanup.argtypes = [ctypes.c_void_p]
m_filter.convolve.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
m_filter.initialize.argtypes = [ndpointer(dtype = numpy.float64),
ctypes.c_int,
ctypes.c_int,
ctypes.c_int]
m_filter.initialize.restype = ctypes.c_void_p
class MatchedFilterException(Exception):
def __init__(self, message):
"""
Python interface to dbscan.so library.
Hazen 11/11
"""
import ctypes
import math
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
lib_dbscan = loadclib.loadCLibrary("dbscan")
lib_dbscan.dbscan.argtypes = [ndpointer(dtype=numpy.float32),
ndpointer(dtype=numpy.float32),
ndpointer(dtype=numpy.float32),
ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ctypes.c_int,
ctypes.c_float,
ctypes.c_int,
ctypes.c_int]
lib_dbscan.locClSize.argtypes = [ndpointer(dtype=numpy.int32),
ndpointer(dtype=numpy.int32),
ctypes.c_int,
ctypes.c_int]
def loadCubicFitC():
cubic_fit = loadclib.loadCLibrary("cubic_fit")
# From sa_library/multi_fit.c
cubic_fit.mFitAnscombeTransformImage.argtypes = [ctypes.c_void_p]
cubic_fit.mFitGetFitImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
cubic_fit.mFitGetNError.argtypes = [ctypes.c_void_p]
cubic_fit.mFitGetNError.restype = ctypes.c_int
cubic_fit.mFitGetPeakPropertyDouble.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p]
cubic_fit.mFitGetPeakPropertyInt.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32),
ctypes.c_char_p]
cubic_fit.mFitGetResidual.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
cubic_fit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
cubic_fit.mFitGetUnconverged.restype = ctypes.c_int
cubic_fit.mFitIterateLM.argtypes = [ctypes.c_void_p]
cubic_fit.mFitNewBackground.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
cubic_fit.mFitNewImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
cubic_fit.mFitRemoveErrorPeaks.argtypes = [ctypes.c_void_p]
cubic_fit.mFitRemoveRunningPeaks.argtypes = [ctypes.c_void_p]
cubic_fit.mFitSetPeakStatus.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32)]
# From spliner/cubic_spline.c
cubic_fit.getZSize.argtypes = [ctypes.c_void_p]
cubic_fit.getZSize.restype = ctypes.c_int
cubic_fit.initSpline2D.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_int,
ctypes.c_int]
cubic_fit.initSpline2D.restype = ctypes.c_void_p
cubic_fit.initSpline3D.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_int,
ctypes.c_int,
ctypes.c_int]
cubic_fit.initSpline3D.restype = ctypes.c_void_p
# From spliner/cubic_fit.c
cubic_fit.cfCleanup.argtypes = [ctypes.c_void_p]
cubic_fit.cfInitialize.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
cubic_fit.cfInitialize.restype = ctypes.POINTER(daoFitC.fitData)
cubic_fit.cfInitialize2D.argtypes = [ctypes.c_void_p]
cubic_fit.cfInitialize3D.argtypes = [ctypes.c_void_p]
cubic_fit.cfInitialize3DALS.argtypes = [ctypes.c_void_p]
cubic_fit.cfInitialize3DLS.argtypes = [ctypes.c_void_p]
cubic_fit.cfInitialize3DFWLS.argtypes = [ctypes.c_void_p]
cubic_fit.cfNewPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p,
ctypes.c_int]
return cubic_fit
#!/usr/bin/env python
"""
Simple Python interface to pupil_function.c
Hazen 10/17
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
pupil_fn = loadclib.loadCLibrary("pupil_function")
pupil_fn.pfnCleanup.argtypes = [ctypes.c_void_p]
pupil_fn.pfnGetPSF.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
pupil_fn.pfnGetPSFIntensity.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
pupil_fn.pfnGetPSFdx.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
pupil_fn.pfnGetPSFdy.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
def loadDaoFitC():
daofit = loadclib.loadCLibrary("dao_fit")
# These are from sa_library/multi_fit.c
daofit.mFitAnscombeTransformImage.argtypes = [ctypes.c_void_p]
daofit.mFitGetFitImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitGetNError.argtypes = [ctypes.c_void_p]
daofit.mFitGetNError.restype = ctypes.c_int
daofit.mFitGetPeakPropertyDouble.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p]
daofit.mFitGetPeakPropertyInt.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32),
ctypes.c_char_p]
daofit.mFitGetResidual.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
daofit.mFitGetUnconverged.restype = ctypes.c_int
daofit.mFitIterateLM.argtypes = [ctypes.c_void_p]
daofit.mFitNewBackground.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitNewImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitRemoveErrorPeaks.argtypes = [ctypes.c_void_p]
daofit.mFitRemoveRunningPeaks.argtypes = [ctypes.c_void_p]
daofit.mFitSetPeakStatus.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32)]
# These are from sa_library/dao_fit.c
daofit.daoCleanup.argtypes = [ctypes.c_void_p]
daofit.daoInitialize.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int]
daofit.daoInitialize.restype = ctypes.POINTER(fitData)
daofit.daoInitialize2DFixed.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2DFixedALS.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2DFixedLS.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2DFixedDWLS.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2DFixedFWLS.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize2DALS.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize2DLS.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize2DDWLS.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize2DFWLS.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize3D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitializeZ.argtypes = [ctypes.c_void_p]
daofit.daoInitializeZ.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_double]
daofit.daoNewPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p,
ctypes.c_int]
return daofit
#!/usr/bin/python
#
# Draws guassians onto a user supplied image.
#
# Hazen 01/16
#
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
drawgauss = loadclib.loadCLibrary("storm_analysis.simulator", "draw_gaussians")
drawgauss.drawGaussians.argtypes = [ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64),
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int]
def cDrawGaussians(image, objects, resolution):
c_image = numpy.ascontiguousarray(image, dtype = numpy.float64)
c_objects = numpy.ascontiguousarray(objects, dtype = numpy.float64)
drawgauss.drawGaussians(c_image,
c_objects,
c_image.shape[1],
c_image.shape[0],
#!/usr/bin/env python
#
# Simply Python interface to matched_filter.c
#
# Hazen 3/16
#
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
m_filter = loadclib.loadCLibrary("storm_analysis.sa_library", "matched_filter")
m_filter.cleanup.argtypes = [ctypes.c_void_p]
m_filter.convolve.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64),
ndpointer(dtype = numpy.float64)]
m_filter.initialize.argtypes = [ndpointer(dtype = numpy.float64),
ctypes.c_int,
ctypes.c_int,
ctypes.c_int]
m_filter.initialize.restype = ctypes.c_void_p
class MatchedFilterException(Exception):
def __init__(self, message):
#!/usr/bin/env python
#
# Python interface to the C avemlist library.
#
# Hazen 10/16
#
import ctypes
import os
from storm_analysis import asciiString
import storm_analysis.sa_library.loadclib as loadclib
c_avemlist = loadclib.loadCLibrary("storm_analysis.sa_utilities", "avemlist")
c_avemlist.avemlist.argtypes = [ctypes.c_int,
ctypes.c_void_p]
def avemlist(input_filename, output_filename):
argc = 3
argv = (ctypes.c_char_p * argc)()
argv[:] = [asciiString(elt) for elt in ["avemlist",
input_filename,
output_filename]]
c_avemlist.avemlist(argc, argv)
if (__name__ == "__main__"):
import sys
avemlist(*sys.argv[1:])
#!/usr/bin/env python
"""
Python interface to ADMM Lasso C library.
Hazen 02/18
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
admm_lasso = loadclib.loadCLibrary("storm_analysis.admm", "admm_lasso")
# C interface definition.
admm_lasso.getXVector.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
admm_lasso.initialize.argtypes = [
ndpointer(dtype=numpy.float64), ctypes.c_double, ctypes.c_int, ctypes.c_int
]
admm_lasso.initialize.restype = ctypes.c_void_p
admm_lasso.iterate.argtypes = [ctypes.c_void_p, ctypes.c_double, ctypes.c_int]
admm_lasso.newImage.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
# "Video-rate nanoscopy using sCMOS camera-specific single-molecule localization algorithms"
# F. Huang et al. Nature Methods, 10, p653-658.
#
# Hazen 10/13
#
import ctypes
import math
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
slib = loadclib.loadCLibrary("storm_analysis.sCMOS", "scmos_utilities")
# C interface definition.
slib.deregularize.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_int]
slib.regularize.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_int]
def loadDaoFitC():
daofit = loadclib.loadCLibrary("dao_fit")
# These are from sa_library/multi_fit.c
daofit.mFitAnscombeTransformImage.argtypes = [ctypes.c_void_p]
daofit.mFitGetFitImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitGetNError.argtypes = [ctypes.c_void_p]
daofit.mFitGetNError.restype = ctypes.c_int
daofit.mFitGetPeakPropertyDouble.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p]
daofit.mFitGetPeakPropertyInt.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32),
ctypes.c_char_p]
daofit.mFitGetResidual.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitGetUnconverged.argtypes = [ctypes.c_void_p]
daofit.mFitGetUnconverged.restype = ctypes.c_int
daofit.mFitIterateLM.argtypes = [ctypes.c_void_p]
daofit.mFitNewBackground.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitNewImage.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
daofit.mFitRemoveErrorPeaks.argtypes = [ctypes.c_void_p]
daofit.mFitRemoveRunningPeaks.argtypes = [ctypes.c_void_p]
daofit.mFitSetPeakStatus.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.int32)]
# These are from sa_library/dao_fit.c
daofit.daoCleanup.argtypes = [ctypes.c_void_p]
daofit.daoInitialize.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int]
daofit.daoInitialize.restype = ctypes.POINTER(fitData)
daofit.daoInitialize2DFixed.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2DFixedALS.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2DFixedLS.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2DFixedDWLS.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2DFixedFWLS.argtypes = [ctypes.c_void_p]
daofit.daoInitialize2D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize2DALS.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize2DLS.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize2DDWLS.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize2DFWLS.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitialize3D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
daofit.daoInitializeZ.argtypes = [ctypes.c_void_p]
daofit.daoInitializeZ.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_double]
daofit.daoNewPeaks.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ctypes.c_char_p,
ctypes.c_int]
return daofit
#!/usr/bin/env python
"""
Python interface to the C tracker library. Note that this
library uses static variables so it is not thread safe.
Hazen 10/16
"""
import ctypes
import os
from storm_analysis import asciiString
import storm_analysis.sa_library.loadclib as loadclib
c_tracker = loadclib.loadCLibrary("storm_analysis.sa_utilities", "tracker")
c_tracker.tracker.argtypes = [ctypes.c_int,
ctypes.c_void_p]
def tracker(mlist_filename, descriptor, radius, zmin, zmax, save_track_id = 0):
argc = 7
argv = (ctypes.c_char_p * argc)()
argv[:] = [asciiString(elt) for elt in ["tracker",
mlist_filename,
descriptor,
radius,
zmin,
zmax,
save_track_id]]
c_tracker.tracker(argc, argv)
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import random
import sys
import storm_analysis.spliner.spline2D as spline2D
import storm_analysis.spliner.spline3D as spline3D
import storm_analysis.sa_library.loadclib as loadclib
# Load the library.
cubic = loadclib.loadCLibrary("storm_analysis.spliner", "cubic_spline")
# C interface definition.
cubic.computeDelta2D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
cubic.computeDelta3D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double,
ctypes.c_double]
cubic.dxfSpline2D.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
cubic.dxfSpline2D.restype = ctypes.c_double
#
# Simple Python interface to fista_fft.c
#
# Hazen 2/16
#
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
import storm_analysis.fista.fista_3d as fista3D
fista_fft = loadclib.loadCLibrary("storm_analysis.fista", "fista_fft")
# C interface definition
fista_fft.cleanup.argtypes = [ctypes.c_void_p]
fista_fft.getXVector.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
fista_fft.initialize2D.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
fista_fft.initialize2D.restype = ctypes.c_void_p
fista_fft.initialize3D.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_double,
Note that because the widths in x/y are transposed in the HDF5
format relative to the Insight3 bin format you may need to
update your calibration parameters.
Hazen 1/18
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.sa_h5py as saH5Py
c_fitz = loadclib.loadCLibrary("fitz")
c_fitz.cleanup.argtypes = [ctypes.c_void_p]
c_fitz.initialize.argtypes = [ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_double,
ctypes.c_double,
ctypes.c_double]
c_fitz.initialize.restype = ctypes.c_void_p
c_fitz.findBestZ.argtypes = [ctypes.c_void_p,
ctypes.c_double,
ctypes.c_double]
c_fitz.findBestZ.restype = ctypes.c_double
the other FISTA solver in this project in that it does use an FFT,
so you can use an arbitrary A matrix, at the a substantial speed
cost.
Hazen 07/13
"""
from ctypes import *
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
fista = loadclib.loadCLibrary("storm_analysis.L1H", "_fista_lib")
# C interface definition.
fista.getXVector.argtypes = [ndpointer(dtype=numpy.float64)]
fista.initialize.argtypes = [
ndpointer(dtype=numpy.float64), c_int, c_int, c_int
]
fista.iterateFISTA.argtypes = [c_double, c_double, c_int]
fista.iterateFISTAToL0Target.argtypes = [c_double, c_double, c_int]
fista.iterateFISTAToL0Target.restype = c_int
fista.iterateISTA.argtypes = [c_double, c_double, c_int]
fista.l1Error.restype = c_double
fista.l2Error.restype = c_double
fista.newBVector.argtypes = [ndpointer(dtype=numpy.float64)]
"""
Simple Python interface to fista_fft.c
Hazen 2/16
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
import storm_analysis.fista.fista_3d as fista3D
fista_fft = loadclib.loadCLibrary("fista_fft")
# C interface definition
fista_fft.cleanup.argtypes = [ctypes.c_void_p]
fista_fft.getXVector.argtypes = [
ctypes.c_void_p, ndpointer(dtype=numpy.float64)
]
fista_fft.initialize2D.argtypes = [
ndpointer(dtype=numpy.float64), ctypes.c_double, ctypes.c_int, ctypes.c_int
]
fista_fft.initialize2D.restype = ctypes.c_void_p
fista_fft.initialize3D.argtypes = [
ndpointer(dtype=numpy.float64), ctypes.c_double, ctypes.c_int,
"""
Simple Python interface to fista_fft.c
Hazen 2/16
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.sa_library.recenter_psf as recenterPSF
import storm_analysis.fista.fista_3d as fista3D
fista_fft = loadclib.loadCLibrary("storm_analysis.fista", "fista_fft")
# C interface definition
fista_fft.cleanup.argtypes = [ctypes.c_void_p]
fista_fft.getXVector.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64)]
fista_fft.initialize2D.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
fista_fft.initialize2D.restype = ctypes.c_void_p
fista_fft.initialize3D.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_double,
Simple Python interface to pupil_function.c
Hazen 10/17
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
import storm_analysis.simulator.pupil_math as pupilMath
#import storm_analysis.sa_library.recenter_psf as recenterPSF
pupil_fn = loadclib.loadCLibrary("storm_analysis.sa_library", "pupil_function")
pupil_fn.pfnCleanup.argtypes = [ctypes.c_void_p]
pupil_fn.pfnGetPSF.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64)
]
pupil_fn.pfnGetPSFdx.argtypes = [
ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64)
]
#!/usr/bin/env python
"""
Simple Python interface to psf_fft.c
Hazen 10/17
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import storm_analysis.sa_library.loadclib as loadclib
psf_fft = loadclib.loadCLibrary("psf_fft")
psf_fft.pFTCleanup.argtypes = [ctypes.c_void_p]
psf_fft.pFTGetPSF.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
psf_fft.pFTGetPSFdx.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
psf_fft.pFTGetPSFdy.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
psf_fft.pFTGetPSFdz.argtypes = [ctypes.c_void_p,
ndpointer(dtype = numpy.float64)]
psf_fft.pFTInitialize.argtypes = [ndpointer(dtype = numpy.float64),
#!/usr/bin/env python
"""
Simple Python interface to pf_math.c
Hazen 01/19
"""
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import os
import sys
import storm_analysis.sa_library.loadclib as loadclib
pf_math = loadclib.loadCLibrary("pf_math")
pf_math.pfZernikeGrid.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_int,
ctypes.c_double,
ctypes.c_double,
ctypes.c_double,
ctypes.c_int,
ctypes.c_int]
def zernikeGrid(np_array, scale, m, n, radius = None, center = None):
"""
Calculate the shape of a Zernike polynomial and store it
in np_array.
"""
#
# Hazen
#
import numpy
import os
import scipy
import scipy.ndimage
import ctypes
import numpy
from numpy.ctypeslib import ndpointer
import storm_analysis.sa_library.loadclib as loadclib
rball = loadclib.loadCLibrary("storm_analysis.rolling_ball_bgr", "rolling_ball_lib")
# C interface definition
rball.cleanup.argtypes = [ctypes.c_void_p]
rball.estimateBg.argtypes = [ctypes.c_void_p,
ndpointer(dtype=numpy.float64),
ndpointer(dtype=numpy.float64),
ctypes.c_int,
ctypes.c_int]
rball.init.argtypes = [ndpointer(dtype=numpy.float64),
ctypes.c_int]
rball.init.restype = ctypes.c_void_p
