def draw_line(image, point, neighbor, size):
width, height = size
center_point = (width//2, height//2)
offset = (width//2 - point[0], height//2 - point[1])
image = ImageChops.offset(image, offset[0], offset[1])
draw = ImageDraw.Draw(image)
to_point = ((neighbor[0] + offset[0]) % width, (neighbor[1] + offset[1]) % height)
draw.line((center_point, to_point))
return ImageChops.offset(image, -offset[0], -offset[1])
def draw_line(image, point, neighbor, size):
width, height = size
center_point = (width//2, height//2)
offset = (width//2 - point[0], height//2 - point[1])
image = ImageChops.offset(image, offset[0], offset[1])
draw = ImageDraw.Draw(image)
to_point = ((neighbor[0] + offset[0]) % width, (neighbor[1] + offset[1]) % height)
draw.line((center_point, to_point))
return ImageChops.offset(image, -offset[0], -offset[1])
def voronoi(players=4):
width = randrange(64, 256)
height = randrange(64, 256)
point_count = randrange(players * 3, players * 6)
min_dist = width * height / point_count
print('%s, %s %s %s' % (width, height, min_dist, sqrt(min_dist)))
px, py = 0, 0
points = []
while min_dist > 100 and len(points) < point_count:
while min_dist > 100:
px, py = randrange(width), randrange(height)
for nx, ny in points:
if distance(px, py, nx, ny, width, height) < min_dist:
break
else:
break
min_dist -= 1
points.append((px, py))
#for px, py in points:
# for nx, ny in points:
# print('(%s)-(%s) = %s' % ((px,py),(nx,ny),distance(px, py, nx, ny, width, height)))
path = {}
closest = {}
for p_x, p_y in points:
nearest = {}
for n_x, n_y in points:
if (p_x, p_y) != (n_x, n_y):
dist = distance(p_x, p_y, n_x, n_y, width, height)
nearest[dist] = (n_x, n_y)
sorted = nearest.keys()
sorted.sort()
path[(p_x, p_y)] = [nearest[key] for key in sorted[:3]]
closest[(p_x, p_y)] = sorted[0]
image = Image.new('RGB', (width, height), BARRIER_COLOR)
draw = ImageDraw.Draw(image)
for point in points:
image.putpixel(point, (0, 0, 0))
size = int(sqrt(closest[point])) // 2 - 2
draw.ellipse((point[0] - size, point[1] - size, point[0] + size,
point[1] + size),
fill=LAND_COLOR,
outline=LAND_COLOR)
from_point = (width // 2, height // 2)
for point, path_neighbors in path.items():
offset = (width // 2 - point[0], height // 2 - point[1])
image = ImageChops.offset(image, offset[0], offset[1])
draw = ImageDraw.Draw(image)
for neighbor in path_neighbors:
to_point = ((neighbor[0] + offset[0]) % width,
(neighbor[1] + offset[1]) % height)
draw.line((from_point, to_point),
width=randrange(3, 6),
fill=LAND_COLOR)
image = ImageChops.offset(image, -offset[0], -offset[1])
image = image.resize((width * 4, height * 4))
image.save('voronoi.png')
def voronoi(players=4):
width = randrange(64, 256)
height = randrange(64, 256)
point_count = randrange(players*3, players*6)
min_dist = width * height / point_count
print('%s, %s %s %s' % (width, height, min_dist, sqrt(min_dist)))
px, py = 0, 0
points = []
while min_dist > 100 and len(points) < point_count:
while min_dist > 100:
px, py = randrange(width), randrange(height)
for nx, ny in points:
if distance(px, py, nx, ny, width, height) < min_dist:
break
else:
break
min_dist -= 1
points.append((px, py))
#for px, py in points:
# for nx, ny in points:
# print('(%s)-(%s) = %s' % ((px,py),(nx,ny),distance(px, py, nx, ny, width, height)))
path = {}
closest = {}
for p_x, p_y in points:
nearest = {}
for n_x, n_y in points:
if (p_x, p_y) != (n_x, n_y):
dist = distance(p_x, p_y, n_x, n_y, width, height)
nearest[dist] = (n_x, n_y)
sorted = nearest.keys()
sorted.sort()
path[(p_x, p_y)] = [nearest[key] for key in sorted[:3]]
closest[(p_x, p_y)] = sorted[0]
image = Image.new('RGB', (width, height), BARRIER_COLOR)
draw = ImageDraw.Draw(image)
for point in points:
image.putpixel(point, (0,0,0))
size = int(sqrt(closest[point]))//2 - 2
draw.ellipse((point[0]-size, point[1]-size, point[0]+size, point[1]+size),
fill=LAND_COLOR, outline=LAND_COLOR)
from_point = (width//2, height//2)
for point, path_neighbors in path.items():
offset = (width//2 - point[0], height//2 - point[1])
image = ImageChops.offset(image, offset[0], offset[1])
draw = ImageDraw.Draw(image)
for neighbor in path_neighbors:
to_point = ((neighbor[0] + offset[0]) % width, (neighbor[1] + offset[1]) % height)
draw.line((from_point, to_point), width=randrange(3,6), fill=LAND_COLOR)
image = ImageChops.offset(image, -offset[0], -offset[1])
image = image.resize((width*4, height*4))
image.save('voronoi.png')
def resizeImage(self, imagePath, width, height):
outfile=imagePath+"_"+str(width)+"_"+str(height)
if not os.path.isfile(imagePath):
print imagePath + " does not exist"
return None
#if resized file already exists, return the same
if os.path.isfile(outfile):
return outfile
try:
size = (width,height)
im = Image.open(imagePath)
if im.size[0]==self.reqImgWidth and im.size[1]==self.reqImgHeight:
return imagePath
im.thumbnail(size, Image.ANTIALIAS)
image_size = im.size
thumb = im.crop( (0, 0, size[0], size[1]) )
offset_x = max( (size[0] - image_size[0]) / 2, 0 )
offset_y = max( (size[1] - image_size[1]) / 2, 0 )
thumb = ImageChops.offset(thumb, offset_x, offset_y)
thumb.save(outfile, "JPEG")
return outfile
except IOError:
print "IOError while resizing " + imagePath
return None
def test_stereo(self):
cam = camera.VidereCamera(open("wallcal.ini").read())
#lf = Image.open("wallcal-L.bmp").convert("L")
#rf = Image.open("wallcal-R.bmp").convert("L")
for offset in [ 1, 10, 10.25, 10.5, 10.75, 11, 63]:
lf = Image.open("snap.png").convert("L")
rf = Image.open("snap.png").convert("L")
rf = rf.resize((16 * 640, 480))
rf = ImageChops.offset(rf, -int(offset * 16), 0)
rf = rf.resize((640,480), Image.ANTIALIAS)
for gradient in [ False, True ]:
af = SparseStereoFrame(lf, rf, gradient)
vo = VisualOdometer(cam)
vo.find_keypoints(af)
vo.find_disparities(af)
error = offset - sum([d for (x,y,d) in af.kp]) / len(af.kp)
self.assert_(abs(error) < 0.25)
if 0:
scribble = Image.merge("RGB", (lf,rf,Image.new("L", lf.size))).resize((1280,960))
#scribble = Image.merge("RGB", (Image.fromstring("L", lf.size, af0.lgrad),Image.fromstring("L", lf.size, af0.rgrad),Image.new("L", lf.size))).resize((1280,960))
draw = ImageDraw.Draw(scribble)
for (x,y,d) in af0.kp:
draw.line([ (2*x,2*y), (2*x-2*d,2*y) ], fill = (255,255,255))
for (x,y,d) in af1.kp:
draw.line([ (2*x,2*y+1), (2*x-2*d,2*y+1) ], fill = (0,0,255))
def pad_image(image, **kwargs):
'Pad an image to make it the same aspect ratio of the desired thumbnail.'
img_width, img_height = image.size
des_width, des_height = kwargs['size']
if not (0.1 < float(des_height) / des_width < 10.0):
return image # Doesn't pad the image if the resize ratio is
# exaggerated. Useful in django-filer admin.
fit = (float(img_width) / des_width,
float(img_height) / des_height)
if fit[0] > fit[1]:
new_image_size = (img_width, int(round(des_height * fit[0])))
top = (new_image_size[1] - img_height) / 2
left = 0
elif fit[0] < fit[1]:
new_image_size = (int(round(des_width * fit[1])), img_height)
top = 0
left = (new_image_size[0] - img_width) / 2
else:
return image
try:
# Converts the image to add an alpha layer.
image = image.convert('RGBA')
# Resizes the image.
image = image.crop((0, 0, new_image_size[0], new_image_size[1]))
# Adds an offset to center the image.
new_image = ImageChops.offset(image, left, top)
return new_image
except:
return image
def distort(image_file, glitch = False):
if glitch:
glitch = 1
else:
glitch = 0
x = Image.open(image_file, "r")
x.load()
red, green, blue = x.split()
green = ImageChops.offset(green,
glitch*random.randint(0,3),
glitch*random.randint(0,3))
blue = ImageChops.offset(ImageEnhance.Contrast(blue).enhance(.4),
glitch*random.randint(0,5),
glitch*random.randint(0,5))
Image.merge("RGB", (red, green, blue)).save("vyntage_%s" %
image_file)
def addup(ims,offset): ##must be of len 2**m n=1 while len(ims)>1: newims=[] for i in range(0,len(ims),2): #print 'offset = %d'%(-offset*n) newims.append(ImageChops.add(ims[i],ImageChops.offset(ims[i+1],offset*n,0),2,0)) ims = newims n*=2 return ims[0]
def addup2(ims,offset): ##must be of len 2**m n=len(ims)+1 #do all the offsets ims = [ImageChops.offset(im,-offset*(n/2-i),0) for i,im in enumerate(ims)] #add all the images, two at a time to avoid overflow while len(ims)>1: ims = [ImageChops.add(ims[i],ims[i+1],2,0) for i in range(0,len(ims),2)] return ims[0]
def combine(ims,offset): n=len(ims)-1 #do all the offsets ims = [ImageChops.offset(im,-offset*(n/2-i),0) for i,im in enumerate(ims)] #add all the images, two at a time to avoid overflow while len(ims)>1: ims = [ImageChops.add(ims[i],ims[i+1],2,0) for i in range(0,len(ims),2)] #return the final result image return ims[0]
def getCategoryIcon(category):
categoryIcons = Image.open(self.__basepath + 'categoryicons18px.png')
#icon = Image.new('RGBA', (18,18), (255,255,255,0))
categories = ('restaurant', 'bar', 'cafe', 'place', 'album', 'song', 'artist', 'film', 'tv_show',
'book', 'software', 'other')
if category not in categories:
categoryIndex = len(categories)-1
else:
categoryIndex = categories.index(category)
print categoryIndex
icon = ImageChops.offset(categoryIcons, -20*categoryIndex, 20)
icon = icon.crop((0, 0, 18, 18))
#icon.paste(categoryIcons, (20*categoryIndex, 20, (20*categoryIndex)+18, 38))
return icon
def test_stereo_accuracy(self):
fd = FeatureDetectorStar(300)
ds = DescriptorSchemeSAD()
for offset in [1, 10, 10.25, 10.5, 10.75, 11, 63]:
lf = self.img640x480
rf = self.img640x480
rf = rf.resize((16 * 640, 480))
rf = ImageChops.offset(rf, -int(offset * 16), 0)
rf = rf.resize((640, 480), Image.ANTIALIAS)
for gradient in [False, True]:
af = SparseStereoFrame(lf,
rf,
gradient,
feature_detector=fd,
descriptor_scheme=ds)
kp = [(x, y, d) for (x, y, d) in af.features() if (x > 64)]
error = offset - sum([d for (x, y, d) in kp]) / len(kp)
print error
self.assert_(abs(error) < 0.25)
def runAnimation(direction="out", stepsSpeed = 1): global motions, config run = True dirUnit = 1 * config.stroopSteps blockWidth = 1 blockPos = 0 blockDir = 1 panelWidth = config.screenWidth /2 panelHeight = config.screenHeight if (direction == "in") : dirUnit = -1 * config.stroopSteps # need to add each text-image to a single composite # but move each side in or out each cycle while ( run == True) : for i in range(0,2) : ref = motions[i] image = ref[0] n = ref[1] side = ref[2] offset = ref[3] speed = ref[4] if(side == "Left") : motions[i][1] = n - dirUnit*config.stroopSteps xPos = 0 xBlock = panelWidth - blockWidth - blockPos*blockDir if(side == "Right") : motions[i][1] = n + dirUnit*blockDir*config.stroopSteps xPos = panelWidth xBlock = 0 + blockPos # crop and load invertedBlock = ImageChops.offset(image,int(n),0) invertedBlock = invertedBlock.crop((0,0,panelWidth,panelHeight)) config.render(invertedBlock,xPos,0,panelWidth,panelHeight,False) time.sleep(config.stroopSpeed)
def test_feature_detectors(self):
L = self.img640x480
R = ImageChops.offset(L, -3, 0)
for fdt in [
FeatureDetectorFast, FeatureDetectorStar, FeatureDetectorHarris
]:
feat = []
for count in range(30, 300, 5):
fd = fdt(count)
frame = SparseStereoFrame(L,
R,
feature_detector=fd,
descriptor_scheme=None)
prev_feat, feat = feat, frame.features()
# At least half the number of features requested
self.assert_((count / 2) < len(feat))
# Should never return too many features - too few is OK because of stereo
self.assert_(len(feat) <= count)
# Should have same or more features with greater count
self.assert_(len(prev_feat) <= len(feat))
# Previous feature call is always a sublist of this feature call
self.assert_(feat[:len(prev_feat)] == prev_feat)
def to_image(self, full_repeat=False):
"""
Convert the pattern to an image. Optional you can specify to convert
the image to a full repeat (based on the drop value).
"""
# Calculate the repeats needed if creating a full repeat
repeats = 1
if full_repeat:
repeats = int(self.size[1] / self.drop)
# Create the image
image = Image.new('RGB', (self.size[0] * repeats, self.size[1]))
pixels = [self.channels[bit] for bit in self.bitmap]
pattern = Image.new('RGB', self.size)
pattern.putdata(pixels)
# Paste the pattern on to the image
for repeat in range(0, repeats):
image.paste(pattern, (self.size[0] * repeat, 0))
pattern = ImageChops.offset(pattern, 0, self.drop)
return image
def run(self):
while True:
self.imagePath = self.queueIMG.get()
self.imageDir, self.imageName = os.path.split(self.imagePath)
self.thumbDir = os.path.join(self.imageDir, "@eaDir",
self.imageName)
print "\t[-]Now working on %s" % (self.imagePath)
if os.path.isfile(os.path.join(self.thumbDir, xlName)) != 1:
if os.path.isdir(self.thumbDir) != 1:
try:
os.makedirs(self.thumbDir)
except:
continue
#Following if statements converts raw images using dcraw first
if os.path.splitext(self.imagePath)[1].lower() == ".cr2":
self.dcrawcmd = "dcraw -c -b 8 -q 0 -w -H 5 '%s'" % self.imagePath
self.dcraw_proc = subprocess.Popen(shlex.split(
self.dcrawcmd),
stdout=subprocess.PIPE)
self.raw = StringIO(self.dcraw_proc.communicate()[0])
self.image = Image.open(self.raw)
else:
self.image = Image.open(self.imagePath)
###### Check image orientation and rotate if necessary
## code adapted from: http://www.lifl.fr/~riquetd/auto-rotating-pictures-using-pil.html
self.exif = self.image._getexif()
if not self.exif:
return False
self.orientation_key = 274 # cf ExifTags
if self.orientation_key in self.exif:
self.orientation = self.exif[self.orientation_key]
rotate_values = {3: 180, 6: 270, 8: 90}
if self.orientation in rotate_values:
self.image = self.image.rotate(
rotate_values[self.orientation])
#### end of orientation part
self.image.thumbnail(xlSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir, xlName),
quality=90)
self.image.thumbnail(lSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir, lName), quality=90)
self.image.thumbnail(bSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir, bName), quality=90)
self.image.thumbnail(mSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir, mName), quality=90)
self.image.thumbnail(sSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir, sName), quality=90)
self.image.thumbnail(pSize, Image.ANTIALIAS)
# pad out image
self.image_size = self.image.size
self.preview_img = self.image.crop((0, 0, pSize[0], pSize[1]))
self.offset_x = max((pSize[0] - self.image_size[0]) / 2, 0)
self.offset_y = max((pSize[1] - self.image_size[1]) / 2, 0)
self.preview_img = ImageChops.offset(self.preview_img,
self.offset_x,
self.offset_y)
self.preview_img.save(os.path.join(self.thumbDir, pName),
quality=90)
self.queueIMG.task_done()
def offset(image, horizontal_offset, vertical_offset=None):
return ImageChops.offset(image, horizontal_offset, vertical_offset)
def run(self):
while True:
self.imagePath=self.queueIMG.get()
self.imageDir,self.imageName = os.path.split(self.imagePath)
self.thumbDir=os.path.join(self.imageDir,"@eaDir",self.imageName)
print "\t[-]Now working on %s" % (self.imagePath)
if os.path.isfile(os.path.join(self.thumbDir,xlName)) != 1:
if os.path.isdir(self.thumbDir) != 1:
try:os.makedirs(self.thumbDir)
except:continue
#Following if statements converts raw images using dcraw first
if os.path.splitext(self.imagePath)[1].lower() == ".cr2":
self.dcrawcmd = "dcraw -c -b 8 -q 0 -w -H 5 '%s'" % self.imagePath
self.dcraw_proc = subprocess.Popen(shlex.split(self.dcrawcmd), stdout=subprocess.PIPE)
self.raw = StringIO(self.dcraw_proc.communicate()[0])
self.image=Image.open(self.raw)
else:
self.image=Image.open(self.imagePath)
###### Check image orientation and rotate if necessary
## code adapted from: http://www.lifl.fr/~riquetd/auto-rotating-pictures-using-pil.html
self.exif = self.image._getexif()
if not self.exif:
return False
self.orientation_key = 274 # cf ExifTags
if self.orientation_key in self.exif:
self.orientation = self.exif[self.orientation_key]
rotate_values = {
3: 180,
6: 270,
8: 90
}
if self.orientation in rotate_values:
self.image=self.image.rotate(rotate_values[self.orientation])
#### end of orientation part
self.image.thumbnail(xlSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir,xlName), quality=90)
self.image.thumbnail(lSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir,lName), quality=90)
self.image.thumbnail(bSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir,bName), quality=90)
self.image.thumbnail(mSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir,mName), quality=90)
self.image.thumbnail(sSize, Image.ANTIALIAS)
self.image.save(os.path.join(self.thumbDir,sName), quality=90)
self.image.thumbnail(pSize, Image.ANTIALIAS)
# pad out image
self.image_size = self.image.size
self.preview_img = self.image.crop((0, 0, pSize[0], pSize[1]))
self.offset_x = max((pSize[0] - self.image_size[0]) / 2, 0)
self.offset_y = max((pSize[1] - self.image_size[1]) / 2, 0)
self.preview_img = ImageChops.offset(self.preview_img, self.offset_x, self.offset_y)
self.preview_img.save(os.path.join(self.thumbDir,pName), quality=90)
self.queueIMG.task_done()
def offset(self, xoffset, yoffset=None):
"(deprecated) Offset image in horizontal and/or vertical direction"
import ImageChops
return ImageChops.offset(self, xoffset, yoffset)
def offset(image, horizontal_offset, vertical_offset=None):
return ImageChops.offset(image, horizontal_offset, vertical_offset)
i1 = Image.eval(small, bw)
i1.save("/tmp/i1.jpg")
print "I1, orig, saved."
i2 = ImageChops.duplicate(i1)
marked = Image.eval(marked, bw)
merge = i2
# calculate spread that works well with your scaling factor
spread = int(round(i1.size[0] / (scaling_factor * 75.)))
# wherever there's a dark pixel, darken all pixels within spread pixels
for x in range(-spread, spread, 1):
for y in range(-spread, spread, 1):
print spread, x, y
newi = ImageChops.offset(i2, x, y)
merge = ImageChops.darker(merge, newi)
i2 = merge
i2.save("/tmp/i2.jpg")
print "I2, mask, saved"
i3 = i2.resize((i1.size[0], i1.size[1]))
i3.save("/tmp/i3.jpg")
print "I3 saved"
i4 = Image.eval(i3, bw)
rot = i1.rotate(.5)
i5 = ImageChops.darker(rot, i4)
rot = i1.rotate(1.)
i6 = ImageChops.darker(rot, i4)
def main():
arg_len = len(sys.argv)
if arg_len < 2:
print('Usage: spectrum.py <input file> <(optional) output file>')
if arg_len >= 2:
input_filename = sys.argv[1]
output_filename = input_filename + '.mp4'
if arg_len == 3:
output_filename = sys.argv[2]
call(['ffmpeg',
'-i', input_filename,
input_filename + '.wav'
])
rate, data = wavfile.read(input_filename + '.wav')
data = data.transpose()
L = data[0]
R = data[1]
im = Image.new("RGBA", IMAGE_SIZE, BACKGROUND)
draw = ImageDraw.Draw(im)
line = Image.new("RGBA", (1, LINE_HEIGHT))
line_draw = ImageDraw.Draw(line)
for y in xrange(LINE_HEIGHT):
fill = hsv2rgb(float(y)/LINE_HEIGHT*120,1,1)
# fill = interpolate(float(y)/LINE_HEIGHT, LINE_START, LINE_END)
line_draw.point((0,y), fill = fill)
try:
for i, fft in enumerate(build_fft(L)):
x_offset = 0
y_offset = 5
width, height = im.size
im = ImageChops.offset(im, x_offset, -y_offset)
enhancer = ImageEnhance.Brightness(im)
im = enhancer.enhance(.98)
#pix = im.load()
draw = ImageDraw.Draw(im)
draw.rectangle((0, 0, x_offset, height), BACKGROUND)
draw.rectangle((0, height + y_offset, width, height), BACKGROUND)
prev = None
for x, y in enumerate(fft):
# y = math.sqrt(abs(y.real) * 1e2) * 10
# y = abs(y.real) * 10
y = math.log(abs(y.real) + 1) * 35
# print(y)
y = min(LINE_HEIGHT, y)
#fill=hsv2rgb((i*3) % 360, 1, 1)
#fill = (255-int(y*1.3),)*3
#print(fill)
#draw.line((x_, height, x_, height-y), fill=fill) #interpolate(float(x)/nFFT, LINE_START, LINE_END))
from_box = (0, LINE_HEIGHT - int(y), 1, LINE_HEIGHT)
region = line.crop(from_box)
x = (x + nFFT/2) % nFFT
x += (im.size[0] - nFFT) / 2
# y_bot = height - (nFFT/2 - x/2) # Slanty
y_bot = height
to_box = (x, y_bot - int(y), x+1, y_bot)
#to_box = (0, height - int(y) - (nFFT - x), 1, height - (nFFT - x))
im.paste(region, to_box)
if prev:
draw.line((x-1, y_bot - prev, x, y_bot - y), fill=(0,0,0,0))
prev = y
im.save('tmp/%07d.png' % i)
except KeyboardInterrupt:
pass
call(["ffmpeg",
"-y",
"-i", input_filename,
"-shortest",
"-r", str(FPS),
"-i", 'tmp/%07d.png',
"-pix_fmt", "yuv420p",
"-r", str(FPS),
output_filename])
if path.exists(output_filename):
os.system('rm tmp/*')
os.unlink(input_filename + '.wav')
"""
Program name: image_offset_1.py
Objective: Make a reduced copy of an image.
Keywords: Image, offset, jpg,
============================================================================79
Explanation: Simple syntax to change image size
Author: Mike Ohlson de Fine
"""
# image_offset_1.py
# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
import Image
import ImageChops
im_1 = Image.open("/constr/pics1/canary_a.jpg")
# adjust width and height to desired size
dx = 200
dy = 300
im_2 = ImageChops.offset(im_1, dx, dy)
im_2.save("/constr/picsx/canary_2.jpg")
def main():
arg_len = len(sys.argv)
if arg_len < 2:
print('Usage: spectrum.py <input file> <(optional) output file>')
if arg_len >= 2:
input_filename = sys.argv[1]
output_filename = input_filename + '.mp4'
if arg_len == 3:
output_filename = sys.argv[2]
call(['ffmpeg', '-i', input_filename, input_filename + '.wav'])
rate, data = wavfile.read(input_filename + '.wav')
data = data.transpose()
L = data[0]
R = data[1]
im = Image.new("RGBA", IMAGE_SIZE, BACKGROUND)
draw = ImageDraw.Draw(im)
line = Image.new("RGBA", (1, LINE_HEIGHT))
line_draw = ImageDraw.Draw(line)
for y in xrange(LINE_HEIGHT):
fill = hsv2rgb(float(y) / LINE_HEIGHT * 120, 1, 1)
# fill = interpolate(float(y)/LINE_HEIGHT, LINE_START, LINE_END)
line_draw.point((0, y), fill=fill)
try:
for i, fft in enumerate(build_fft(L)):
x_offset = 0
y_offset = 5
width, height = im.size
im = ImageChops.offset(im, x_offset, -y_offset)
enhancer = ImageEnhance.Brightness(im)
im = enhancer.enhance(.98)
#pix = im.load()
draw = ImageDraw.Draw(im)
draw.rectangle((0, 0, x_offset, height), BACKGROUND)
draw.rectangle((0, height + y_offset, width, height), BACKGROUND)
prev = None
for x, y in enumerate(fft):
# y = math.sqrt(abs(y.real) * 1e2) * 10
# y = abs(y.real) * 10
y = math.log(abs(y.real) + 1) * 35
# print(y)
y = min(LINE_HEIGHT, y)
#fill=hsv2rgb((i*3) % 360, 1, 1)
#fill = (255-int(y*1.3),)*3
#print(fill)
#draw.line((x_, height, x_, height-y), fill=fill) #interpolate(float(x)/nFFT, LINE_START, LINE_END))
from_box = (0, LINE_HEIGHT - int(y), 1, LINE_HEIGHT)
region = line.crop(from_box)
x = (x + nFFT / 2) % nFFT
x += (im.size[0] - nFFT) / 2
# y_bot = height - (nFFT/2 - x/2) # Slanty
y_bot = height
to_box = (x, y_bot - int(y), x + 1, y_bot)
#to_box = (0, height - int(y) - (nFFT - x), 1, height - (nFFT - x))
im.paste(region, to_box)
if prev:
draw.line((x - 1, y_bot - prev, x, y_bot - y),
fill=(0, 0, 0, 0))
prev = y
im.save('tmp/%07d.png' % i)
except KeyboardInterrupt:
pass
call([
"ffmpeg", "-y", "-i", input_filename, "-shortest", "-r",
str(FPS), "-i", 'tmp/%07d.png', "-pix_fmt", "yuv420p", "-r",
str(FPS), output_filename
])
if path.exists(output_filename):
os.system('rm tmp/*')
os.unlink(input_filename + '.wav')
def differ(im,off): return ImageChops.difference(im,ImageChops.offset(im,off,0)) #find the median contrast at each pixel in each of the 20 shiftadded photos ds = [ImageChops.add(differ(im,1),differ(im,-1),2,0).filter(ImageFilter.MedianFilter(11)) for im in ims]
import requests
import Image, ImageChops
URL="http://*****:*****@www.pythonchallenge.com/pc/return/mozart.gif"
proxy = {
'http': 'child-prc.intel.com:913',
'https': 'child-prc.intel.com:913',
}
IMG_NAME = r"16.gif"
r = requests.get(URL, proxies=proxy,) #auth=HTTPBasicAuth(USERNAME, PASSWORD))
r.raise_for_status()
with open(IMG_NAME, "wb") as handle:
handle.write(r.content)
magic = chr(195) # pink color
im = Image.open(IMG_NAME)
width, height = im.size
for y in range(height):
crop_zone = 0, y, width, y+1
row = im.crop(crop_zone)
bs = row.tostring()
i = bs.index(magic)
row = ImageChops.offset(row, -i)
im.paste(row, crop_zone)
im.save('16-gen.gif')
import zlib
import Image
import ImageChops
import struct
import sys
offset = (128, 128)
if not len(sys.argv)>1:
print "Rata puuttuu, hölö!"
sys.exit(1)
i = Image.open(sys.argv[1])
o = open(sys.argv[1].replace(".png",".trk"),"wb")
i = ImageChops.offset(i, offset[0], offset[1])
"""
last = None
runlen = 0
bytes = 0
compressed = ""
for y in range(0,i.size[1]):
for x in range(0,i.size[0]):
p = i.getpixel((x,y))
if p == last and runlen<255:
runlen += 1
else:
if runlen:
compressed += chr(p | 0x80) + chr(runlen)
else:
