def LoadData(path1, path2, model):
quantizer = Quantization(model.getNumCutOffs())
quantizer.setCutOffs(model.getCutOffs())
faceData = ReadDataSet(path1)
quantizedFaceData = quantizer.runQuantization(faceData)
del faceData
nonfaceData = ReadDataSet(path2)
quantizedNonFaceData = quantizer.runQuantization(nonfaceData)
del nonfaceData
return quantizedFaceData, quantizedNonFaceData
def LoadData(path1, path2):
faceData = ReadDataSet(path1)
quantizer = Quantization(settings.NUM_CUTOFF)
cutoffs = quantizer.initQuantization(faceData)
quantizedFaceData = quantizer.runQuantization(faceData)
del faceData
nonfaceData = ReadDataSet(path2)
quantizedNonFaceData = quantizer.runQuantization(nonfaceData)
del nonfaceData
return quantizedFaceData, quantizedNonFaceData, cutoffs
def LoadData(path1, path2):
faceData = ReadDataSet(path1)
quantizer = Quantization(settings.NUM_CUTOFF)
cutoffs = quantizer.initQuantization(faceData)
quantizedFaceData = quantizer.runQuantization(faceData)
del faceData
nonfaceData = ReadDataSet(path2)
quantizedNonFaceData = quantizer.runQuantization(nonfaceData)
del nonfaceData
return quantizedFaceData, quantizedNonFaceData, cutoffs
def __init__(self, image_matrix, sigma=0.5):
if sigma >= 0.:
mask = np.ones(image_matrix.shape, dtype=bool)
fsmooth = lambda x: ndi.gaussian_filter(x, sigma, mode='constant')
self.imin = smooth_with_function_and_mask(image_matrix, fsmooth, mask)
else:
self.imin = image_matrix
self.centroids = Quantization.measCentroid(self.imin, 2)
nq = np.array([[x * 255] for x in range(0, 2)])
self.imin = Quantization.quantMatrix(self.imin, nq, self.centroids)
plt.imshow(self.imin, cmap=cm.gray)
plt.savefig("figStartOrig.png")
plt.clf()
self.ibin = np.zeros(self.imin.shape, dtype=np.uint8)
x0,y0 = np.where(self.imin == 0)
self.ibin[x0,y0] = 1
skel = skeletonize(self.ibin)
self.skeleton = skel.astype(np.uint8)
plt.imshow(self.skeleton, cmap=cm.gray)
plt.savefig("figStartSkel.png")
plt.clf()
self.segments = Segments.Segments()
for neighbor_limit in range(1,5):
while True:
self.count_neighbors()
for internal_limit in range(1,neighbor_limit+1):
startx, starty = np.where(self.neighbor_count == internal_limit)
if len(startx) > 0:
break
if len(startx) == 0:
break
for (x,y) in zip(startx, starty):
if self.skeleton[x,y] == 1:
self.follow_line(x,y)
print(np.sum(self.skeleton))
print(np.sum(self.neighbor_count))
print(np.max(self.neighbor_count))
assert (np.sum(self.neighbor_count) == 0)
def encoding(bs, width, heigth):
DCY, DCU, DCV, ACY, ACU, ACV = Compress.encoding(bs, height, width)
YBlocks = DC.DPCM2(DCY)
UBlocks = DC.DPCM2(DCU)
VBlocks = DC.DPCM2(DCV)
for i in range(len(YBlocks)):
AC.Z2Tab(ACY[i], YBlocks[i])
YBlocks[i] = Quantization.reY(YBlocks[i])
YBlocks[i] = DCT.IDCT(YBlocks[i])
for i in range(len(UBlocks)):
AC.Z2Tab(ACU[i], UBlocks[i])
UBlocks[i] = Quantization.reUV(UBlocks[i])
UBlocks[i] = DCT.IDCT(UBlocks[i])
for i in range(len(VBlocks)):
AC.Z2Tab(ACV[i], VBlocks[i])
VBlocks[i] = Quantization.reUV(VBlocks[i])
VBlocks[i] = DCT.IDCT(VBlocks[i])
Y, U, V = DCT.merge(YBlocks, UBlocks, VBlocks, height, width)
img = RGB2YUV.yuv2rgb(Y, U, V, width, height)
cv2.imwrite(r'../photograph_JPEG.jpeg', img)
cv2.imshow("img after encoding", img)
cv2.waitKey(0)
cv2.destroyAllWindows()
def LoadData(path1, path2, model):
quantizer = Quantization(model.getNumCutOffs())
quantizer.setCutOffs(model.getCutOffs())
faceData = ReadDataSet(path1)
quantizedFaceData = quantizer.runQuantization(faceData)
del faceData
nonfaceData = ReadDataSet(path2)
quantizedNonFaceData = quantizer.runQuantization(nonfaceData)
del nonfaceData
return quantizedFaceData, quantizedNonFaceData
def __init__(self, image_matrix, white=1, levels=4, init_shape=3):
"""
:param image_matrix:
"""
self.dnCount = 0
self.dnSum = 0.
self.upCount = 0
self.upSum = 0.
self.lenList = list()
self.imin = image_matrix
self.xmin = 0
self.ymin = 0
self.xmax = self.imin.shape[0] - 1
self.ymax = self.imin.shape[1] - 1
# whiten
self.imin /= white
self.imin += 255 - (255 // white)
# quantize
self.centroids = Quantization.measCentroid(self.imin, levels)
print(self.centroids)
levels = min(levels, len(self.centroids))
levels = max(2, levels)
nq = np.array([[x * 255 / (levels - 1)] for x in range(0, levels)])
self.imin = Quantization.quantMatrix(self.imin, nq, self.centroids)
plt.imshow(self.imin, cmap=cm.gray)
plt.savefig("figStartOrig.png")
plt.clf()
# self.R0_B = self.density(nq[-1][0])
# Initial segment
if init_shape == 1:
moore = []
m = []
n = 1 << 7
for i in range(0, n**2):
x, y = Hilbert.d2xy(n, i, True)
m.append((x, y))
moore.append(((self.imin.shape[0] * x) / (n - 1),
(self.imin.shape[1] * y) / (n - 1)))
'''
Rotate the moore graph to start in the middle
'''
m2q = len(moore) // 4
moore2 = moore[m2q:]
moore2.extend(moore[:m2q])
'''
Add the first and last point to return to start
'''
ptAlpha = np.multiply(np.array(self.imin.shape), 0.5)
moore2.append(tuple(ptAlpha))
moore2.insert(0, tuple(ptAlpha))
moore3 = [(0.95 * x + 0.025 * self.imin.shape[0],
0.95 * y + 0.025 * self.imin.shape[1])
for x, y in moore2]
self.maze_path = np.array(moore3)
self.plotMazeImage("figStart0.png")
self.maze_path = TSPopt.simplify(self.maze_path)
for i in range(10):
self.resampling()
self.plotMazeImage("figStart1.png")
self.maze_path = TSPopt.simplify(self.maze_path)
while True:
delta, seg1 = TSPopt.threeOptLocal(self.maze_path, 40)
self.maze_path = seg1
if delta == 0.:
break
self.plotMazeImage("figStart2.png")
for i in range(10):
self.resampling()
'''
Have to add a brownian to thois because when you do the resample, you could end up with points
on the same line, which will lead to a divb0 issue.
'''
brownian = self.brownian()
self.maze_path = np.add(self.maze_path, brownian)
self.plotMazeImage("figStart3.png")
elif init_shape == 2:
import LSystem
gosper = LSystem.LSystem(axiom='B',
rules=[('A', 'A-B--B+A++AA+B-'),
('B', '+A-BB--B-A++A+B')],
angle=60.0)
gosper.iterate(5)
self.maze_path = np.array(
gosper.segment(initialpt=[200.0, 600.0], d=4.0))
self.plotMazeImage("figStartGosper0.png")
elif init_shape == 3:
import LSystem
fass2 = LSystem.LSystem(axiom="FX",
rules=[('X', 'Y-LFL-FRF-LFLFL-FRFR+F'),
('Y', 'X+RFR+FLF+RFRFR+FLFL-F'),
('L', 'LF+RFR+FL-F-LFLFL-FRFR+'),
('R', '-LFLF+RFRFR+F+RF-LFL-FR')],
angle=90)
fass2.iterate(5)
path1 = np.array(fass2.segment(initialpt=[0.0, 0.0], d=1.0))
dim = path1.max() - path1.min()
path2 = list()
path1min = path1.min()
for pt in path1:
path2.append(
((self.imin.shape[0] * (pt[0] - path1min)) / (dim - 1),
(self.imin.shape[1] * (pt[1] - path1min)) / (dim - 1)))
path3 = [(0.95 * x + 0.025 * self.imin.shape[0],
0.95 * y + 0.025 * self.imin.shape[1]) for x, y in path2]
self.maze_path = path3
self.plotMazeImage("figFass2_0.png")
self.maze_path = TSPopt.simplify(self.maze_path)
for i in range(10):
self.resampling()
self.plotMazeImage("figFass2_1.png")
self.maze_path = TSPopt.simplify(self.maze_path)
while True:
delta, seg1 = TSPopt.threeOptLocal(self.maze_path, 40)
self.maze_path = seg1
if delta == 0.:
break
self.plotMazeImage("figFass2_2.png")
for i in range(10):
self.resampling()
else:
self.maze_path = [(0., 0.)]
segListEnd = tuple([x - 1 for x in self.imin.shape])
self.maze_path.append(segListEnd)
self.maze_path = np.array(self.maze_path)
self.seg = Segments.Segments()
factor = 0.5
delta = 0.0
self.bndry_xmax = self.xmax + factor * self.R0_B - delta
self.bndry_ymax = self.ymax + factor * self.R0_B - delta
self.bndry_xmin = self.xmin - factor * self.R0_B + delta
self.bndry_ymin = self.ymin - factor * self.R0_B + delta
pt_00 = (self.bndry_xmin, self.bndry_ymin)
pt_01 = (self.bndry_xmin, self.bndry_ymax)
pt_11 = (self.bndry_xmax, self.bndry_ymax)
pt_10 = (self.bndry_xmax, self.bndry_ymin)
self.boundary_seg = [pt_00, pt_01, pt_11, pt_10, pt_00]
self.minDist = sys.float_info.max
import Quantization
import Scaling
import os
def mkdir(path):
if not os.path.exists(path):
os.makedirs(path)
mkdir('./Quantization')
mkdir('./Scale')
Quantization.quantize('10.png', 128, './Quantization/10-level-128.png')
Quantization.quantize('10.png', 32, './Quantization/10-level-32.png')
Quantization.quantize('10.png', 8, './Quantization/10-level-8.png')
Quantization.quantize('10.png', 4, './Quantization/10-level-4.png')
Quantization.quantize('10.png', 2, './Quantization/10-level-2.png')
Scaling.scale('10.png', (192, 128), './Scale/down-scale(192x128).png')
Scaling.scale('10.png', (96, 64), './Scale/down-scale(96x64).png')
Scaling.scale('10.png', (48, 32), './Scale/down-scale(48x32).png')
Scaling.scale('10.png', (24, 16), './Scale/down-scale(24x16).png')
Scaling.scale('10.png', (12, 8), './Scale/down-scale(12x8).png')
Scaling.scale('10.png', (300, 200), './Scale/down-scale(300x200).png')
Scaling.scale('10.png', (450, 300), './Scale/up-scale(450x300).png')
Scaling.scale('10.png', (500, 200), './Scale/scale(500x200).png')
def __init__(self, image_matrix, white=1, levels=4):
"""
:param image_matrix:
:param white:
:param levels:
"""
self.imin = image_matrix
# whiten
self.imin /= white
self.imin += 255 - (255 // white)
# quantize
self.centroids = Quantization.measCentroid(self.imin, levels)
print(self.centroids)
nq = numpy.array([[x * 255 / (levels - 1)] for x in range(0, levels)])
self.imin = Quantization.quantMatrix(self.imin, nq, self.centroids)
misc.imsave("test.png", self.imin)
# stipple
self.stipple()
self.grad = zeros(shape(self.imin), dtype=numpy.int)
misc.imsave("test2.png", self.stipple_im)
seg = self.hilbertSequence()
self.segments = Segments.Segments()
self.segments.append(seg)
# for s in xrange(4, 20, 2):
# while True:
# delta, seg = self.twoOpt(seg, maxdelta=s)
# print delta
# d2 = self.totalLength(seg)
# assert almost_equal(delta, d2 - d)
# d = d2
# if delta == 0:
# break
d = self.totalLength(self.segments.segmentList[0])
while True:
delta, seg2 = TSPopt.threeOptLocal(self.segments.segmentList[0],10)
print("Local: " + str(delta))
d2 = self.totalLength(seg2)
assert almost_equal(delta, d2 - d)
d = d2
self.segments.segmentList[0] = seg2
if delta == 0:
break
d = self.totalLength(self.segments.segmentList[0])
for s in range(2, 4, 2):
while True:
delta, seg2 = TSPopt.threeOptLoop(self.segments.segmentList[0],maxdelta=s)
print("Loop(" + str(s) + "): " + str(delta))
d2 = self.totalLength(seg2)
assert almost_equal(delta, d2 - d)
d = d2
self.segments.segmentList[0] = seg2
if delta == 0:
break
# while True:
# delta = self.segments.threeOptLongs()
# print("Longs: " + str(delta))
# if delta == 0:
# break
d = self.totalLength(self.segments.segmentList[0])
for s in range(2, 8, 2):
while True:
delta,seg2 = TSPopt.threeOptLoop(self.segments.segmentList[0],maxdelta=s)
print("Loop2(" + str(s) + "): " + str(delta))
d2 = self.totalLength(seg2)
assert almost_equal(delta, d2 - d)
d = d2
self.segments.segmentList[0] = seg2
if delta == 0:
break
d = self.totalLength(self.segments.segmentList[0])
while True:
delta, seg2 = TSPopt.threeOptLocal(self.segments.segmentList[0],10)
print("Local: " + str(delta))
d2 = self.totalLength(seg2)
assert almost_equal(delta, d2 - d)
d = d2
self.segments.segmentList[0] = seg2
if delta == 0:
break
def __init__(self, image_matrix, white=1, levels=4, init_shape=INIT_SKEL, maxQuant = 220):
"""
:param image_matrix:
"""
self.dnCount = 0
self.dnSum = 0.
self.upCount = 0
self.upSum = 0.
self.lenList = list()
self.imin = image_matrix
self.xmin = 0
self.ymin = 0
self.xmax = self.imin.shape[0] - 1
self.ymax = self.imin.shape[1] - 1
# whiten
self.imin /= white
self.imin += 255 - (255 // white)
# processor count
self.PROCESSORS = multiprocessing.cpu_count()
if self.PROCESSORS > 1:
self.PROCESSORS -= 1
# quantize
self.centroids = Quantization.measCentroid(self.imin, levels)
print("Centroids: ")
print(self.centroids)
levels = min(levels, len(self.centroids))
levels = max(2, levels)
nq = np.array([[x * maxQuant / (levels - 1)] for x in range(0, levels)])
print(nq)
self.imin = Quantization.quantMatrix(self.imin, nq, self.centroids)
plt.imshow(self.imin, cmap=cm.gray)
plt.savefig("figStartOrig.png")
plt.clf()
# self.R0_B = self.density(nq[-1][0])
# Initial segment
if init_shape == self.INIT_MOORE:
moore = []
m = []
n = 1 << 7
for i in range(0, n ** 2):
x, y = Hilbert.d2xy(n, i, True)
m.append((x, y))
moore.append(((self.imin.shape[0] * x) / (n - 1),
(self.imin.shape[1] * y) / (n - 1)))
'''
Ordinarily, the moore curve starts in the middle of one
edge.
Rotate the moore graph to start in the middle
'''
m2q = len(moore) // 4
moore2 = moore[m2q:]
moore2.extend(moore[:m2q])
'''
Add the first and last point to return to start
'''
ptAlpha = np.multiply(np.array(self.imin.shape), 0.5)
moore2.append(tuple(ptAlpha))
moore2.insert(0, tuple(ptAlpha))
moore3 = [(0.95 * x + 0.025 * self.imin.shape[0], 0.95 * y + 0.025 * self.imin.shape[1]) for x, y in moore2]
self.maze_path = np.array(moore3)
self.maze_path = TSPopt.simplify(self.maze_path)
for i in range(10):
self.resampling()
self.maze_path = TSPopt.simplify(self.maze_path)
while True:
delta, seg1 = TSPopt.threeOptLocal(self.maze_path, 40)
self.maze_path = seg1
if delta == 0.:
break
for i in range(10):
self.resampling()
'''
Have to add a brownian to thois because when you do the resample, you could end up with points
on the same line, which will lead to a divb0 issue.
'''
brownian = self.brownian()
self.maze_path = np.add(self.maze_path, brownian)
self.plotMazeImage("figStartMoore.png",superimpose=True)
elif init_shape == self.INIT_FASS:
""" FASS is for Filling, self-Avoiding, Simple, and self-Similar.
This is one instance of a FASS system. This one starts in the
center, which is why it is advantageous for us.
"""
import LSystem
fass2 = LSystem.LSystem(axiom="FX",
rules=[('X','Y-LFL-FRF-LFLFL-FRFR+F'),
('Y','X+RFR+FLF+RFRFR+FLFL-F'),
('L','LF+RFR+FL-F-LFLFL-FRFR+'),
('R','-LFLF+RFRFR+F+RF-LFL-FR')],
angle = 90)
fass2.iterate(5)
path1=np.array(fass2.segment(initialpt=[0.0,0.0], d=1.0))
dim = path1.max() - path1.min()
path2 = list()
path1min = path1.min()
for pt in path1:
path2.append(((self.imin.shape[0] * (pt[0]-path1min)) / (dim - 1),
(self.imin.shape[1] * (pt[1]-path1min)) / (dim - 1)))
path3 = [(0.95 * x + 0.025 * self.imin.shape[0], 0.95 * y + 0.025 * self.imin.shape[1]) for x, y in path2]
self.maze_path = path3
self.plotMazeImage("figStartFass0.png",superimpose=True)
self.maze_path = TSPopt.simplify(self.maze_path)
for _ in range(10):
self.resampling()
self.maze_path = TSPopt.simplify(self.maze_path)
while True:
delta, seg1 = TSPopt.threeOptLocal(self.maze_path, 40)
self.maze_path = seg1
if delta == 0.:
break
for i in range(10):
self.resampling()
self.plotMazeImage("figStartFass.png",superimpose=True)
elif init_shape == self.INIT_DIAG:
# simple diagonal
segListEnd = tuple([x - 1 for x in self.imin.shape])
self.maze_path = list()
for i in range(20):
self.maze_path.append((int(i*segListEnd[0]/20),
int(i*segListEnd[1]/20)))
self.maze_path.append(segListEnd)
self.maze_path = np.array(self.maze_path)
elif init_shape == self.INIT_SKEL: # use skeleton to cover most of dark image (>128)
b = np.array([[0.], [128.]])
q = np.array([[0.], [1.]])
blacks = Quantization.quantMatrix(self.imin, q, b)
skeleton = Skeleton.Skeleton(blacks)
skeleton.segments.addInitialStartPt()
skeleton.euclidMstOrder()
skeleton.segments.concatSegments()
oneD = skeleton.segments.segmentList.flatten()
self.maze_path = np.reshape(oneD, (-1, 2))
brownian = self.brownian()
self.maze_path = np.add(self.maze_path, brownian)
self.maze_path = TSPopt.simplify(self.maze_path)
size = 60
while True:
delta, seg1 = TSPopt.threeOptLocal(self.maze_path, size)
self.maze_path = seg1
if delta == 0.:
break
size = max(5,size-5)
self.plotMazeImage("figStartSkeleton.png",superimpose=True)
self.seg = Segments.Segments()
factor = 0.5
delta = 0.0
self.bndry_xmax = self.xmax + factor * self.R0_B - delta
self.bndry_ymax = self.ymax + factor * self.R0_B - delta
self.bndry_xmin = self.xmin - factor * self.R0_B + delta
self.bndry_ymin = self.ymin - factor * self.R0_B + delta
pt_00 = (self.bndry_xmin, self.bndry_ymin)
pt_01 = (self.bndry_xmin, self.bndry_ymax)
pt_11 = (self.bndry_xmax, self.bndry_ymax)
pt_10 = (self.bndry_xmax, self.bndry_ymin)
self.boundary_seg = [pt_00, pt_01, pt_11, pt_10, pt_00]
self.minDist = sys.float_info.max
import DCT
import Quantization
import AC
import DC
import Compress
import cv2
def printBlock(block):
for row in block:
print(row)
img = cv2.imread("../photograph.jpg")
DCT = DCT.DCT()
Quantization = Quantization.Quantization()
AC = AC.AC()
DC = DC.DC()
Compress = Compress.Compress()
Y, U, V = RGB2YUV.rgb2yuv(img, img.shape[1], img.shape[0])
Y = DCT.fill(Y)
blocks = DCT.split(Y)
first = blocks[0]
print('The first block of Y:')
printBlock(first)
print('')
print('The DCT of the block:')
first = DCT.FDCT(first)
printBlock(first)
print('')
print('The Quantization of the DCT:')
def compress(path):
img = cv2.imread(path)
height = img.shape[0]
width = img.shape[1]
Y, U, V = RGB2YUV.rgb2yuv(img, img.shape[1], img.shape[0])
Y = DCT.fill(Y)
U = DCT.fill(U)
V = DCT.fill(V)
blocksY = DCT.split(Y)
blocksU = DCT.split(U)
blocksV = DCT.split(V)
FDCT = []
Quan = []
Z = []
ACnum = []
for block in blocksY:
FDCT.append(DCT.FDCT(block))
Quan.append(Quantization.quanY(FDCT[-1]))
Z.append(AC.ZScan(Quan[-1]))
ACnum.append(AC.RLC(Z[-1]))
DCnum = DC.DPCM(Quan)
#print('Y: ')
Bstr0 = ''
for i in range(len(ACnum)):
Bstr0 += Compress.AllCompressY(DCnum[i], ACnum[i])
#print(Bstr0)
#print(len(Bstr0))
FDCT = []
Quan = []
Z = []
ACnum = []
for block in blocksU:
FDCT.append(DCT.FDCT(block))
Quan.append(Quantization.quanUV(FDCT[-1]))
Z.append(AC.ZScan(Quan[-1]))
ACnum.append(AC.RLC(Z[-1]))
DCnum = DC.DPCM(Quan)
#print('U: ')
Bstr1 = ''
for i in range(len(ACnum)):
Bstr1 += Compress.AllCompressUV(DCnum[i], ACnum[i])
#print(Bstr1)
#print(len(Bstr1))
FDCT = []
Quan = []
Z = []
ACnum = []
for block in blocksV:
FDCT.append(DCT.FDCT(block))
Quan.append(Quantization.quanUV(FDCT[-1]))
Z.append(AC.ZScan(Quan[-1]))
ACnum.append(AC.RLC(Z[-1]))
DCnum = DC.DPCM(Quan)
#print('V: ')
Bstr2 = ''
for i in range(len(ACnum)):
Bstr2 += Compress.AllCompressUV(DCnum[i], ACnum[i])
#print(Bstr2)
#print(len(Bstr2))
s = Bstr0 + Bstr1 + Bstr2
print(len(s))
return height, width, s
import RGB2YUV
import DCT
import Quantization
import AC
import DC
import Compress
import cv2
def printBlock(block):
for row in block:
print(row)
DCT = DCT.DCT()
Quantization = Quantization.Quantization()
AC = AC.AC()
DC = DC.DC()
Compress = Compress.Compress()
def compress(path):
img = cv2.imread(path)
height = img.shape[0]
width = img.shape[1]
Y, U, V = RGB2YUV.rgb2yuv(img, img.shape[1], img.shape[0])
Y = DCT.fill(Y)
U = DCT.fill(U)
V = DCT.fill(V)
blocksY = DCT.split(Y)
blocksU = DCT.split(U)
