def gen_next_block(self, public_key, transactions): prev_block = self.chain[-1] index = prev_block.index + 1 timestamp = datetime.datetime.now() data = transactions hashed_block = prev_block.gen_hashed_block() self.chain.append( Block(index, timestamp, data, hashed_block, public_key))
def __init__(self, name: str, body_of_acl: str, parent: object = None): self.name = name self.parent = parent self.interfaces = set() self.ip_interfaces = set() self.calculated_networks = set() self.calculated_statics = set() if CONFIG_CLASS and isinstance(self.parent, config_class.Cisco_Config): self.interfaces = set(self.parent._find_ace_interfaces(self.name)) for intface in self.interfaces: self.ip_interfaces.update(self.parent._get_subnets(intface)) if self.interfaces and self.ip_interfaces: for address in self.ip_interfaces: self.calculated_networks.add( self._calculate_address(address)) for address in self.ip_interfaces: static_route = self._calculated_statics(address) if static_route: self.calculated_statics.add(static_route) self.blocks = [] raw_blocks = self._break_into_blocks(body_of_acl) for block in raw_blocks: self.blocks.append(Block(block, parent=self))
import pygame from pygame import * import block_class from block_class import Block from GraphicsUtil import toplength, topwidth blockWidth = 25 x = 0 y = 0 squiggleSurface2 = pygame.Surface((75,50)) squiggleSurface2.set_colorkey((0,0,0)) B1 = Block(blockWidth,blockWidth, (0,255,255), x, y) B1.groupDrawSquiggleBlock2(squiggleSurface2) class squiggleBlock2: def __init__(self): self.color = 6 self.surface = squiggleSurface2 self.rotate = 0 def points(self): if self.rotate%2==0: return [(0,0), (1,0), (1,1), (2,1)] if self.rotate%2==1: return [(1,0), (0,1), (1,1), (0,2)]
import pygame from pygame import * import block_class from block_class import Block from GraphicsUtil import toplength, topwidth blockWidth = 25 lineXpos = 0 lineYpos = 0 BLUE = (0,0,255) lineSurface = Surface((25,100)) lineSurface.set_colorkey((0,0,0)) B1 = Block(blockWidth,blockWidth, BLUE, lineXpos, lineYpos) B1.groupDrawLineBlock(lineSurface) class lineBlock: def __init__(self): self.color = 2 self.surface = lineSurface self.rotate = 0 def points(self): if self.rotate%2==0: return [(0,0), (0,1), (0,2), (0,3)] if self.rotate%2==1: return [(0,0), (1,0), (2,0), (3,0)]
import pygame from pygame import * import block_class from block_class import Block from GraphicsUtil import toplength, topwidth blockWidth = 25 x = 0 y = 0 squiggleSurface = pygame.Surface((75,50)) squiggleSurface.set_colorkey((0,0,0)) B1 = Block(blockWidth,blockWidth, (0,255,255), x, y) B1.groupDrawSquiggleBlock(squiggleSurface) class squiggleBlock: def __init__(self): self.color = 5 self.surface = squiggleSurface self.rotate = 0 def points(self): if self.rotate%2==0: return [(0,1), (1,0), (2,0), (1,1)] if self.rotate%2==1: return [(0,0), (0,1), (1,1), (1,2)]
from pygame import * import block_class from block_class import Block from GraphicsUtil import toplength, topwidth import GraphicsUtil as Graph blockWidth = 25 x = 0 y = 0 YELLOW = (255, 255, 0) lSurface = pygame.Surface((75,50)) lSurface.set_colorkey((0,0,0)) B1 = Block(blockWidth,blockWidth, YELLOW, x, y) B1.groupDrawlBlock(lSurface) class lBlock: def __init__(self): self.color = 3 self.surface = lSurface self.rotate = 0 def points(self): if self.rotate%4==0: return [(0,0), (1,0), (2,0), (0,1)] if self.rotate%4==3: return [(0,0), (0,1), (0,2), (1,2)] if self.rotate%4==2: return [(0,1), (1,1), (2,1), (2,0)]
def gen_genesis_block(): transaction = [{"Serial": "Genesis", "PubKey": "Placeholder"}] return Block(0, datetime.datetime.now(), transaction, "0", "0")
def draw(screen): #print(score) global currentblock, y, x, state, me if state == gameState: # # setup a different background, # if Graph.TGrid[y][x] != 0: # y = 0 # x = 4 # currentblock = randomeBlock() screen.fill(Graph.BLACK) screen.blit(Graph.grid, (0, 0)) def drawTetramino(x , y, block): pts = block.points() for p in pts: px, py = x+p[0], y+p[1] screen.blit(block.surface, (px*25+Graph.toplength, py*25+Graph.topwidth)) drawTetramino(x, y, currentblock) for i in range (len(Graph.TGrid)): for j in range (len(Graph.TGrid[i])): loc = Graph.TGrid [i][j] if loc != 0: if loc == 1: b = Block(25,25, (255,0,0), j, i) b.indBlock(screen,block_class.yellowBlock) elif loc == 2: b = Block(25,25, (255,0,0), j, i) b.indBlock(screen,block_class.tealBlock) elif loc == 3: b = Block(25,25, (255,0,0), j, i) b.indBlock(screen,block_class.redBlock) elif loc == 4: b = Block(25,25, (255,0,0), j, i) b.indBlock(screen,block_class.greenBlock) elif loc == 5: b = Block(25,25, (255,0,0), j, i) b.indBlock(screen,block_class.blueBlock) elif loc == 6: b = Block(25,25, (255,0,0), j, i) b.indBlock(screen,block_class.orangeBlock) elif loc == 7: b = Block(25,25, (255,0,0), j, i) b.indBlock(screen,block_class.purpleBlock) # Clear a row and score when complete bonus = -50 for i in Graph.TGrid: global score, tick, permtick, level if 0 not in i: Graph.TGrid.remove(i) Graph.TGrid.insert(0,[0,0,0,0,0,0,0,0,0,0]) score += 100 level += 100 bonus += 50 if level >= 500: level -= 500 permtick += 8 tick += 8 if bonus >= 0: score += bonus level += bonus # return score text = font.render(str(score),1,(255,255,255)) #Draws Boxes On The Side screen.blit(Graph.scoreSurface, (325, 400)) screen.blit(Graph.scoreWordSurface, (325, 330)) screen.blit(text, (335,415)) screen.blit(Graph.nextSurface, (325, 50)) screen.blit(Graph.nextShowSurface, (325, 115)) drawTetramino(14.5, 6, nextBlock) screen.blit(Graph.gridGraphicSurface, (0, 0)) #Draws Box Behind Grid #screen.blit(Graph.gridGraphicSurface, (18, 5)) elif state == endGameState: # pygame.mixer.music.stop() # print ('endgame called') pygame.display.flip() endScoreSurface = pygame.Surface((200, 50)) endScoreImage = pygame.image.load("ScoreBox.png") endScoreImage = pygame.transform.scale(endScoreImage, (200, 50)) endScoreSurface.blit(endScoreImage, (0, 0)) screen.fill(Graph.BLACK) text = font.render('Score: ' + str(score),1,(255,255,255)) text2 = font.render('press M to return to menu',1,(255,255,255)) screen.blit(endScoreSurface, (185,235)) screen.blit(text, (205,250)) screen.blit(text2, (130,450)) elif state == menuState: resetGame() pygame.display.flip() # print ('menu state called') screen.fill(Graph.BLACK) screen.blit(chazFundatory,(180,170)) startbutton = Menu.Button("Play Game", screen, 180, 90, 200, 50) startbutton.draw(Menu.playButton)
import pygame from pygame import * import block_class from block_class import Block from GraphicsUtil import toplength, topwidth blockWidth = 25 squareXpos = 0 squareYpos = 0 squareSurface = pygame.Surface((50,50)) squareSurface.set_colorkey((0,0,0)) B1 = Block(blockWidth,blockWidth, (255,0,0), squareXpos, squareYpos) B1.groupDrawSquareBlock(squareSurface) class squareBlock: def __init__(self): self.color = 1 self.surface = squareSurface self.rotate = 0 def points(self): return [(0,0), (1,1), (1,0), (0,1)] # def groundDraw:
def expanding_block(filename, *, debug=False): """ Tests an image for copy-move forgery (a portion of an image has been copied and then moved somewhere else within the image.) Written by Efron Licht, based off the algorithm "An efficient expanding block algorithm for image copy-move forgery detection" by Gavin Lynch, Frank Y. Shih, and Hong-Yuan Mark Liao, and published in Information Sciences 239 in 2013. Free for noncommerical use or modification, but please retain the above credits. Please ask for commerical use. input: filename that contains an mxn image (color or grayscale) known valid formats: '.png', '.jpg' output: imageConsideredModified, imgOut where imageConsideredModified is True | False if imageConsideredModified == True, imgOut is the original image if imageConsideredModified == False, imgOut is a (2m+8) x n x 3 image """ """ file IO and conversion to grayscale: """ baseImg = io.imread(filename) try: # color.rgb2gray converts to doubles on unit scale (0<pixel<1) # so we rescale back to uint8 img = np.uint8(255 * color.rgb2gray(baseImg)) except ValueError as valError: shape = np.shape(baseImg) if shape[2] == 1: # image is grayscale already img = baseImg # convert image into a a 3D array (psuedo-RGB) so as to not handle # so many unique cases later baseImg = np.uint8(255 * color.gray2rgb(baseImg)) else: raise valError init = ExpandingBlockInit(img) rows = np.shape(img)[0] - init.blockSize cols = np.shape(img)[1] - init.blockSize blocks = ([ Block(img, row, col, init) for row in range(rows) for col in range(cols) ]) blocks = sorted(blocks, key=lambda block: block.variance) """ remove elements with too low of variance to cut down on false positives due to bad white balance on source camera or areas of block color """ blocks = [block for block in blocks if not block.tooLowVariance] """ assign blocks as evenly as possible to groups """ groups = [[] for x in range(init.numBuckets)] # we don't want to use * to avoid nasty by-reference bugs blocksPerBucket = len(blocks) / init.numBuckets group = 0 count = 0 for block in blocks: groups[group].append(block) count += 1 if count > blocksPerBucket: group += 1 count -= blocksPerBucket """ assign groups to buckets """ buckets = [None] * init.numBuckets for n in range(init.numBuckets): try: buckets[n] = groups[n - 1] + groups[n] + groups[n + 1] except IndexError: if n == init.numBuckets - 1: buckets[n] = groups[n - 1] + groups[n] else: raise IndexError """ process buckets for pixel-to-pixel similiarity. see process_bucket """ buckets = [process_bucket(bucket) for bucket in buckets] """ recombine buckets after processing, removing empty buckets """ blocks = [block for bucket in buckets for block in bucket] """ if there are no blocks left, the image is clean """ if len(blocks) == 0: imageConsideredModified = False return imageConsideredModified, baseImg #else imageConsideredModified = True """ otherwise, we create a masked image to show where the modification occurs """ mask = create_mask(blocks, baseImg, init) imgOut = np.uint8(write_mask(mask, baseImg)) if debug: io.imshow(imgOut) return imageConsideredModified, imgOut
def expanding_block(filename, *, _debug=False): """ Tests an image for copy-move forgery (a portion of an image has been copied and then moved somewhere else within the image.) Written by Efron Licht, based off the algorithm "An efficient expanding block algorithm for image copy-move forgery detection" by Gavin Lynch, Frank Y. Shih, and Hong-Yuan Mark Liao, and published in Information Sciences 239 in 2013. Free for noncommerical use or modification, but please retain the above credits. Please ask for commerical use. input: filename that contains an mxn image (color or grayscale) known valid formats: '.png', '.jpg' output: imageConsideredModified, imgOut where imageConsideredModified is True | False if imageConsideredModified == True, imgOut is the original image if imageConsideredModified == False, imgOut is a (2m+8) x n x 3 image """ """ helper functions """ def _generate_groups(blocks): """ assign blocks within image evenly to groups""" group = [] blocksPerGroup = len(blocks) / init.numBuckets group = 0 count = 0 for block in blocks: if len(group) >= blocksPerGroup: yield group count -= blocksPerGroup group = [] group.append(block) count += 1 if len(group) > 0: yield group def _generate_buckets(groups): """ assign blocks within groups to overlapping buckets """ for n in range(len(groups)): try: bucket = groups[n - 1] + groups[n] + groups[n + 1] except IndexError: if n == init.numBuckets - 1: bucket = groups[n - 1] + groups[n] else: raise yield bucket """ MAIN FUNCTION START """ #0. file IO and conversion to grayscale: baseImg = io.imread(filename) try: # color.rgb2gray converts to doubles on unit scale (0<pixel<1) # so we rescale back to uint8 img = np.uint8(255 * color.rgb2gray(baseImg)) except ValueError: shape = np.shape(baseImg) if shape[2] == 1: # image is grayscale already img = baseImg # convert image into a a 3D array (psuedo-RGB) so as to not handle # so many unique cases later baseImg = np.uint8(255 * color.gray2rgb(baseImg)) else: raise init = ExpandingBlockInit(img) rows, cols, *_ = np.shape(img) - init.blockSize blocks = ((Block(img, row, col, init) for row in range(rows) for col in range(cols))) blocks = sorted(blocks, key=lambda block: block.variance) #1. remove elements with too low of variance to cut down on false positives # due to bad white balance on source camera or areas of block color blocks = dropwhile(lambda block: block.tooLowVariance, blocks) #2. assign blocks as evenly as possible to groups groups = _generate_groups(blocks) #3. assign blocks in neighboring groups to overlapping buckets buckets = _generate_buckets(groups) #4. process buckets for pixel-to-pixel similiarity. see process_bucket buckets = (process_bucket(bucket) for bucket in buckets) #buckets now hold blocks that we think are modified. #5. recombine buckets after processing blocks = [block for bucket in buckets for block in bucket] #6a. Image is considered clean if no blocks left after processing if len(blocks) == 0: imageConsideredModified = False imgOut = baseImg #6b. If image is considered modified,create mask for image else: imageConsideredModified = True mask = create_mask(blocks, baseImg, init) #7b. Paint mask over image imgOut = np.uint8(write_mask(mask, baseImg)) #8. Output. if _debug: io.imshow(imgOut) return imageConsideredModified, imgOut