import cv2
import matplotlib.pyplot as plt
from lbp import LBP
from TAS import tas
from sklearn.decomposition import PCA
positives = glob('positives/*.jpg') # Authentic images
negatives = glob('negatives/*.jpg') #spliced images
Features = [] #Final Feature matrix
for im in (positives + negatives):
img = cv2.imread(im) # read image one by one
features = [] # features for current image
features = list(mahotas.features.haralick(img).mean(0)) #haralick
features += list(Zernike(img)) #zernike
features += (list(sift(img))) #sift
Features.append(features)
#Apply KPCA for feature reduction
# will select best 440 features out of one image
kpca = KernelPCA(n_components=440, kernel='rbf')
Features = kpca.fit_transform(Features)
labels = [1] * len(positives) + [0] * len(negatives) #Labels
#creating SVM Classifier
learner = milk.defaultclassifier()
#model = learner.train(Features, labels)
start = timer()
def __init__(self):
"""The Simulator object simulates the camera, mirror, and dynamic aberrations
of the system. CIAO can be run in simulation mode by instantiating a simulator
object, then a sensor object using the simulator as its camera, and then a
loop object using that sensor and the simulator in place of the mirror."""
self.frame_timer = FrameTimer('simulator')
# We need to define a meshes on which to build the simulated spots images
# and the simulated wavefront:
self.sy = ccfg.image_height_px
self.sx = ccfg.image_width_px
self.wavefront = np.zeros((self.sy, self.sx))
# Some parameters for the spots image:
self.dc = 100
self.spots_range = 2000
self.spots = np.ones((self.sy, self.sx)) * self.dc
self.spots = self.noise(self.spots)
self.pixel_size_m = ccfg.pixel_size_m
# compute single spot
self.lenslet_pitch_m = ccfg.lenslet_pitch_m
self.f = ccfg.lenslet_focal_length_m
self.L = ccfg.wavelength_m
fwhm_px = (1.22 * self.L * self.f /
self.lenslet_pitch_m) / self.pixel_size_m
xvec = np.arange(self.sx)
yvec = np.arange(self.sy)
xvec = xvec - xvec.mean()
yvec = yvec - yvec.mean()
XX, YY = np.meshgrid(xvec, yvec)
d = np.sqrt(XX**2 + YY**2)
self.beam_diameter_m = ccfg.beam_diameter_m
self.beam_radius_m = self.beam_diameter_m / 2.0
self.disc_diameter = 170
#self.disc_diameter = ccfg.beam_diameter_m/self.pixel_size_m # was just set to 110
self.disc = np.zeros((self.sy, self.sx))
self.disc[np.where(d <= self.disc_diameter)] = 1.0
self.X = np.arange(self.sx, dtype=np.float) * self.pixel_size_m
self.Y = np.arange(self.sy, dtype=np.float) * self.pixel_size_m
self.X = self.X - self.X.mean()
self.Y = self.Y - self.Y.mean()
self.XX, self.YY = np.meshgrid(self.X, self.Y)
self.RR = np.sqrt(self.XX**2 + self.YY**2)
self.mask = np.zeros(self.RR.shape)
self.mask[np.where(self.RR <= self.beam_radius_m)] = 1.0
use_partially_illuminated_lenslets = True
if use_partially_illuminated_lenslets:
d_lenslets = int(
np.ceil(self.beam_diameter_m / self.lenslet_pitch_m))
else:
d_lenslets = int(
np.floor(self.beam_diameter_m / self.lenslet_pitch_m))
rad = float(d_lenslets) / 2.0
xx, yy = np.meshgrid(np.arange(d_lenslets), np.arange(d_lenslets))
xx = xx - float(d_lenslets - 1) / 2.0
yy = yy - float(d_lenslets - 1) / 2.0
d = np.sqrt(xx**2 + yy**2)
self.lenslet_mask = np.zeros(xx.shape, dtype=np.uint8)
self.lenslet_mask[np.where(d <= rad)] = 1
self.n_lenslets = int(np.sum(self.lenslet_mask))
self.x_lenslet_coords = xx * self.lenslet_pitch_m / self.pixel_size_m + self.sx / 2.0
self.y_lenslet_coords = yy * self.lenslet_pitch_m / self.pixel_size_m + self.sy / 2.0
in_pupil = np.where(self.lenslet_mask)
self.x_lenslet_coords = self.x_lenslet_coords[in_pupil]
self.y_lenslet_coords = self.y_lenslet_coords[in_pupil]
self.lenslet_boxes = SearchBoxes(self.x_lenslet_coords,
self.y_lenslet_coords,
ccfg.search_box_half_width)
#plt.plot(self.x_lenslet_coords,self.y_lenslet_coords,'ks')
#plt.show()
self.mirror_mask = np.loadtxt(ccfg.mirror_mask_filename)
self.n_actuators = int(np.sum(self.mirror_mask))
self.command = np.zeros(self.n_actuators)
# virtual actuator spacing in magnified or demagnified
# plane of camera
actuator_spacing = ccfg.beam_diameter_m / float(
self.mirror_mask.shape[0])
ay, ax = np.where(self.mirror_mask)
ay = ay * actuator_spacing
ax = ax * actuator_spacing
ay = ay - ay.mean()
ax = ax - ax.mean()
self.flat = np.loadtxt(ccfg.mirror_flat_filename)
self.flat0 = np.loadtxt(ccfg.mirror_flat_filename)
self.n_zernike_terms = ccfg.n_zernike_terms
#actuator_sigma = actuator_spacing*0.75
actuator_sigma = actuator_spacing * 1.5
self.exposure = 10000 # microseconds
key = '%d' % hash((tuple(ax), tuple(ay), actuator_sigma, tuple(
self.X), tuple(self.Y), self.n_zernike_terms))
key = key.replace('-', 'm')
try:
os.mkdir(ccfg.simulator_cache_directory)
except OSError as e:
pass
cfn = os.path.join(ccfg.simulator_cache_directory,
'%s_actuator_basis.npy' % key)
try:
self.actuator_basis = np.load(cfn)
print 'Loading cached actuator basis set...'
except Exception as e:
actuator_basis = []
print 'Building actuator basis set...'
for x, y in zip(ax, ay):
xx = self.XX - x
yy = self.YY - y
surf = np.exp((-(xx**2 + yy**2) / (2 * actuator_sigma**2)))
surf = (surf - surf.min()) / (surf.max() - surf.min())
actuator_basis.append(surf.ravel())
plt.clf()
plt.imshow(surf)
plt.title('generating actuator basis\n%0.2e,%0.2e' % (x, y))
plt.pause(.1)
self.actuator_basis = np.array(actuator_basis)
np.save(cfn, self.actuator_basis)
zfn = os.path.join(ccfg.simulator_cache_directory,
'%s_zernike_basis.npy' % key)
self.zernike = Zernike()
try:
self.zernike_basis = np.load(zfn)
print 'Loading cached zernike basis set...'
except Exception as e:
zernike_basis = []
print 'Building zernike basis set...'
#zernike = Zernike()
for z in range(self.n_zernike_terms):
surf = self.zernike.get_j_surface(z, self.XX, self.YY)
zernike_basis.append(surf.ravel())
self.zernike_basis = np.array(zernike_basis)
np.save(zfn, self.zernike_basis)
#self.new_error_sigma = np.ones(self.n_zernike_terms)*100.0
self.zernike_orders = np.zeros(self.n_zernike_terms)
for j in range(self.n_zernike_terms):
self.zernike_orders[j] = self.zernike.j2nm(j)[0]
self.baseline_error_sigma = 1.0 / (1.0 + self.zernike_orders) * 10.0
self.baseline_error_sigma[3:6] = 150.0
self.new_error_sigma = self.zernike_orders / 10.0 / 100.0
# don't generate any piston, tip, or tilt:
self.baseline_error_sigma[:3] = 0.0
self.new_error_sigma[:3] = 0.0
self.error = self.get_error(self.baseline_error_sigma)
self.paused = False
