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 __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 __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)