def parseColorSchemes(fileName):
df = pandas.read_csv(fileName,
usecols=["schemeLabel", "maskLabel", "r", "g", "b"],
dtype={
"schemeLabel": "str",
"maskLabel": "str",
"r": "int",
"g": "int",
"b": "int"
})
numRows = len(df)
myDict = dict()
for index in range(numRows):
schemeLabel = df.iloc[index]['schemeLabel']
maskLabel = df.iloc[index]['maskLabel']
pixel = Pixel.Pixel(df.iloc[index]['r'], df.iloc[index]['g'],
df.iloc[index]['b'], "RGB")
if schemeLabel not in myDict.keys():
myDict[schemeLabel] = ColorScheme.ColorScheme(schemeLabel)
myDict[schemeLabel].addLabelPixel(maskLabel, pixel)
colorSchemes = []
for value in myDict.values():
colorSchemes.append(value)
return colorSchemes
def main():
pl = []
p1 = Pixel.Pixel(0, 0, 0)
p2 = Pixel.Pixel(0, 0, 0)
p3 = Pixel.Pixel(0, 0, 0)
p4 = Pixel.Pixel(31, 57, 219)
p5 = Pixel.Pixel(31, 57, 219)
p6 = Pixel.Pixel(31, 57, 219)
p7 = Pixel.Pixel(0, 0, 0)
p8 = Pixel.Pixel(0, 0, 0)
p9 = Pixel.Pixel(0, 0, 0)
p10 = Pixel.Pixel(255, 255, 255)
pl.extend([p1, p2, p3, p4, p5, p6, p7, p8, p9, p10])
k = Kernel(pl)
print k.__dict__
return k
def create_pixel_array(self, img):
pixels = []
for line in range(0, self.height):
for column in range(0, self.width):
pixel = Pixel.Pixel(line, column,
True if img[line][column] == 1 else False)
pixels.append(pixel)
return pixels
def setKernelsandRGB(self, show=False):
'''
For each entry in self.cobs, it will open the file with that name in repDirectory.
The file is a csv file of the format "accessionName, Kernel, R, G, B". This function will return a list of
ints that correspond to the number of kernels that are associated with the Cob file.
'''
print "Creating Kernels and Pixels"
progressBar = 0
for key in self.cobs:
progressBar += 1
kernelList = []
filePath = self.repDirectory + "/" + key + ".tif.csv"
with open(filePath) as csvFile:
csvReader = csv.reader(csvFile)
csvList = list(csvReader)
print "Cob: ", progressBar, "/", len(self.cobs)
listofpixels = []
currentKernel = 1
for line in csvList:
try:
if line[0] == 'Image':
pass
elif int(line[1]) != currentKernel and line[4] != '':
kernelList.append(
Kernel.Kernel(listofpixels,
name=currentKernel))
if show == True:
print "Kernel: %s" % currentKernel
listofpixels = []
currentKernel = int(line[1])
currentPixel = Pixel.Pixel(int(line[2]),
int(line[3]),
int(line[4]))
listofpixels.append(currentPixel)
elif int(line[1]) == currentKernel:
currentPixel = Pixel.Pixel(int(line[2]),
int(line[3]),
int(line[4]))
listofpixels.append(currentPixel)
except:
IndexError
self.cobs[key] = Cob.Cob(kernelList)
print "Kernel's Initialized for %s" % key
print "All Cob's Initialized"
def color_skin_regions(img_path, save_path):
image = Image.open(img_path)
pixels = image.load()
width = image.size[0]
height = image.size[1]
for i in xrange(0, width):
for j in xrange(0, height):
pixel = Pixel(i, j, pixels[i,j][0], pixels[i, j][1], pixels[i, j][2])
if pixel.is_skin():
pixels[i, j] = (0, 0, 0)
image.save(save_path)
def processing(mode, pix, width, height, draw, image):
print(str(mode + 1) + ". Image")
pbar.start()
for i in range(width):
for j in range(height):
pixel = Pixel.Pixel(*pix[i, j])
draw.point((i, j), (pixel.modeget(mode)))
pbar.update(i * j)
del pixel
image.save("Image" + str(mode + 1) + ".jpg", "JPEG")
print('')
def negative(mode, pix, width, height, draw, image):
print(str(mode + 1) + ". Negative")
pbar.start()
for i in range(width):
for j in range(height):
pixel = Pixel.Pixel(*pix[i, j])
red, green, blue = pixel.modeget(mode)
draw.point((i, j), (255 - red, 255 - green, 255 - blue))
pbar.update(i * j)
del pixel
image.save("Negative" + str(mode + 1) + ".jpg", "JPEG")
print('')
def update_pixel_array(self, img):
for line in range(0, self.height):
for column in range(0, self.width):
pixel = Pixel.Pixel(line, column,
True if img[line][column] == 1 else False)
if pixel not in self.arrayPixelsImage:
self.arrayPixelsImage.append(pixel)
elif pixel in self.arrayPixelsImage:
idx = self.arrayPixelsImage.index(pixel)
self.arrayPixelsImage[idx] = pixel
self.arrayPixelsImage.sort(key=lambda k: [k.x, k.y])
def __init__(self, bitmap, wid, hi):
self.wid = wid
self.hi = hi
result = []
level = []
for i in range(wid * hi):
level.append(
Pixel(blue=bitmap[i * 3],
green=bitmap[i * 3 + 1],
red=bitmap[i * 3 + 2]))
if wid == len(level):
result.insert(0, level)
level = []
self.bitmap = result
def processImageRGBA(image: Image, mask: Mask, colorScheme: ColorScheme):
result = Image.new("RGBA", image.size)
for x in range(image.size[0]):
for y in range(image.size[1]):
p = image.getpixel((x, y))
p_r, p_g, p_b, p_a = p
pixel = Pixel.Pixel(p_r, p_g, p_b, "RGB")
pixelLabel = mask.getLabel(pixel)
tPixel = colorScheme.getPixel(pixelLabel)
if pixelLabel != "":
result.putpixel((x, y), (tPixel.r, tPixel.g, tPixel.b, p_a))
else: # if it doesn't map to any known values
result.putpixel((x, y), p)
return result
def init():
SCREEN.fill(BLACK)
pygame.display.update()
world = []
for y in range(int(SCREEN_HEIGHT / PIXEL_SIZE)):
row = []
for x in range(int(SCREEN_WIDTH / PIXEL_SIZE)):
pixel = Pixel.Pixel(SCREEN, x, y, PIXEL_SIZE)
pixel.draw()
row.append(pixel)
world.append(row)
user_pick(world) # let user pick starting state
# Draw a glider gun
# for (y, x) in GLIDER_GUN: world[y][x].color = WHITE
return world
def parse(bitmap, wid, hi):
"""
Parsing map to list of pixels
:param bitmap:
:param wid:
:param hi:
:return:
"""
result = []
level = []
for i in range(wid * hi):
level.append(
Pixel(blue=bitmap[i * 3],
green=bitmap[i * 3 + 1],
red=bitmap[i * 3 + 2]))
if wid == len(level):
result.insert(0, level)
level = []
return result
def parseMask(fileName):
df = pandas.read_csv(fileName,
usecols=["label", "r", "g", "b"],
dtype={
"label": "str",
"r": "int",
"g": "int",
"b": "int"
})
numRows = len(df)
mask = Mask.Mask()
for index in range(numRows):
pixel = Pixel.Pixel(df.iloc[index]['r'], df.iloc[index]['g'],
df.iloc[index]['b'], "RGB")
mask.addPixelLabel(df.iloc[index]['label'], pixel)
return mask
def decode(low_data):
"""
Decodes image
:param low_data:
:return:
"""
hex_str = low_data.hex()
bits = "".join([
"{0:08b}".format(int(hex_str[x:x + 2], base=16))
for x in range(0, len(hex_str), 2)
])
codes = decode_code(bits)
differences = [x // 2 if x % 2 == 0 else -(x // 2) for x in codes]
bitmap = [
Pixel(int(differences[i + 2]), int(differences[i + 1]),
int(differences[i])) for i in range(0, len(differences), 3)
]
bitmap = diff_decode(bitmap)
bitmap = convert_to_list(bitmap)
return bytes(bitmap)
def contains_nudity(image_path):
image = Image.open(image_path)
imgPixels = image.load()
width = image.size[0]
height = image.size[1]
pixels = [ [None]*height for i in range(width) ]
for i in xrange(0, width):
for j in xrange(0, height):
pixels[i][j] = Pixel(i, j, imgPixels[i,j][0], imgPixels[i,j][1], imgPixels[i,j][2])
skin_pixels = []
skin_regions = []
create_skin_regions(pixels, skin_pixels, skin_regions, width, height)
if len(skin_regions) < 3:
return False
skin_regions.sort(key = operator.attrgetter('size'), reverse=True)
bounding_region = create_bounding_region(pixels, skin_regions, width, height)
return analyze_regions(skin_pixels, skin_regions, bounding_region, width, height)
def percolate(bitmap, x, y, high=False):
"""
Filters upper,lower
:param bitmap:
:param x:
:param y:
:param high:
:return:
"""
w1 = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
w2 = [[0, -1, 0], [-1, 5, -1], [0, -1, 0]]
weights = w2 if high else w1
pixel_org = Pixel(0, 0, 0)
for i in range(-1, 2):
for j in range(-1, 2):
pixel_org += bitmap[x + i, y + j] * weights[i + 1][j + 1]
weights_sum = sum([sum(level) for level in weights])
if weights_sum <= 0:
weights_sum = 1
pixel_org = pixel_org // weights_sum
setup_pixel(pixel_org)
return pixel_org
def stick_pieces(bloc_p, bloc_e, p, e, final_stick=False):
"""
Stick an edge of a piece to the bloc of already resolved pieces
:param bloc_p: bloc of pieces already solved
:param bloc_e: bloc of edges already solved
:param p: piece to add to the bloc
:param e: edge to stick
:return: Nothing
"""
f = open('./testfile.txt', 'w+')
vec_bloc = np.subtract(bloc_e.shape[0], bloc_e.shape[-1])
vec_piece = np.subtract(e.shape[0], e.shape[-1])
translation = np.subtract(bloc_e.shape[0], e.shape[-1])
angle = angle_between((vec_bloc[0], vec_bloc[1], 0),
(-vec_piece[0], -vec_piece[1], 0))
# file = open('coords.txt','w+')
# file.write(str(angle) + '\n')
# file.close()
# First move the first corner of piece to the corner of bloc edge
for edge in p.edges_:
edge.shape += translation
# Then rotate piece of `angle` degrees centered on the corner
for edge in p.edges_:
for i, point in enumerate(edge.shape):
edge.shape[i] = rotate(bloc_e.shape[0], point, -angle)
if final_stick:
#prev bounding box
minX, minY, maxX, maxY = float('inf'), float(
'inf'), -float('inf'), -float('inf')
for i, pixel in enumerate(p.img_piece_):
x, y = p.img_piece_[i].translate(translation[1], translation[0])
minX, minY, maxX, maxY = min(minX,
x), min(minY,
y), max(maxX,
x), max(maxY, y)
# pixel.rotate(bloc_e.shape[0], -angle)
#rotation center
img_p = np.full((maxX - minX + 1, maxY - minY + 1, 3), -1)
for pix in p.img_piece_:
x, y = pix.pos
x, y = x - minX, y - minY
img_p[x, y] = pix.color
#new bounding box
minX2, minY2, maxX2, maxY2 = float('inf'), float(
'inf'), -float('inf'), -float('inf')
for x in [minX, maxX]:
for y in [minY, maxY]:
x2, y2 = rotate((bloc_e.shape[0][1], bloc_e.shape[0][0]),
(x, y), angle)
x2, y2 = int(x2), int(y2)
minX2, minY2, maxX2, maxY2 = min(minX2, x2), min(
minY2, y2), max(maxX2, x2), max(maxY2, y2)
f.write(str(x2) + ', ' + str(y2) + '\n')
pixels = []
for px in range(minX2, maxX2 + 1):
for py in range(minY2, maxY2 + 1):
qx, qy = rotate((bloc_e.shape[0][1], bloc_e.shape[0][0]),
(px, py), -angle)
qx, qy = int(qx), int(qy)
if minX <= qx <= maxX and minY <= qy <= maxY and img_p[
qx - minX, qy - minY][0] != -1:
pixels.append(Pixel((px, py), img_p[qx - minX, qy - minY]))
finalAng = angle * (180 / 3.14159)
while finalAng > 360:
finalAng = finalAng - 360
while finalAng < 0:
finalAng = finalAng + 360
# print('Angle:', finalAng)
file.write(str(finalAng) + '\n')
p.img_piece_ = pixels
def getPixel(self, label: str):
if label in self.__labelPixelDict:
return self.__labelPixelDict[label]
return Pixel.Pixel(255,0,255,"RGB")
def main():
IMAGE_NAME = sys.argv[1]
pixel = Pixel.Pixel(0, 0, 0)
modsquantity = pixel.getmodsquantity()
selectedmods = []
print("Available modes:", modsquantity)
wrongoption = True
while (wrongoption):
print("-p, -P \t Positive mods;")
print("-n, -N \t Negative mods;")
print("-a, -A \t All mods;")
global administration
administration = list(input("Select mods: ").split(" "))
select = administration[:-1]
print(administration)
if len(select) == 1:
select = select[0]
print(select)
if select.startswith("-"):
modenumber = select[1:]
if modenumber.isdigit():
selectedmods = list(range(int(modenumber) - 1))
wrongoption = False
else:
print('Wrong option 1')
elif select.endswith("-"):
modenumber = select[:-1]
if modenumber.isdigit():
selectedmods = list(
range(int(modenumber) - 1, modsquantity))
wrongoption = False
else:
print('Wrong option 2')
elif select.find('-') != -1:
try:
modenumber = list(map(int, select.split("-")))
selectedmods = list(range(modenumber[0] - 1,
modenumber[1]))
wrongoption = False
except:
print('Wrong option 3')
else:
selectedmods.append(int(select) - 1)
wrongoption = False
else:
selectedmods = list(map(int, select))
#try:
for i in range(len(selectedmods)):
selectedmods[i] = selectedmods[i] - 1
wrongoption = False
#except:
# print('Wrong option 4')
print(
'----------------------------------------------------------------')
del pixel
for mode in selectedmods:
image = Image.open(IMAGE_NAME)
draw = ImageDraw.Draw(image)
width = image.size[0]
height = image.size[1]
global pbar
pbar = ProgressBar(maxval=width * height)
pix = image.load()
if administration[-1] == '-p' or administration[-1] == '-P':
processing(mode=mode,
pix=pix,
width=width,
height=height,
draw=draw,
image=image)
elif administration[-1] == '-n' or administration[-1] == '-N':
negative(mode=mode,
pix=pix,
width=width,
height=height,
draw=draw,
image=image)
elif administration[-1] == '-a' or administration[-1] == '-A':
processing(mode=mode,
pix=pix,
width=width,
height=height,
draw=draw,
image=image)
negative(mode=mode,
pix=pix,
width=width,
height=height,
draw=draw,
image=image)
print('')
