def add_image(self, image):
output = StringIO()
im = Image.open(image)
im.thumbnail((384, 384), Image.ANTIALIAS)
ImageOps.flip(im).convert('1').save(output, 'BMP')
content = 'P:%s' % b64encode(output.getvalue())
self.contents.append(content)
def main():
p = ArgumentParser()
p.add_argument("--outdir", nargs="?", default="")
p.add_argument("--skip-existing", action="store_true")
p.add_argument("--only", type=str, nargs="?", help="Extract specific IDs")
p.add_argument("files", nargs="+")
args = p.parse_args(sys.argv[1:])
cards, textures = extract_info(args.files)
paths = [card["path"] for card in cards.values()]
print("Found %i cards, %i textures including %i unique in use." % (
len(cards), len(textures), len(set(paths))
))
orig_dir = "orig"
thumb_sizes = (256, 512)
tiles_dir = "tiles"
filter_ids = args.only.split(",") if args.only else []
for id, values in sorted(cards.items()):
if filter_ids and id not in filter_ids:
continue
path = values["path"]
print("Parsing %r (%r)" % (id, path))
if not path:
print("%r does not have a texture" % (id))
continue
if path not in textures:
print("Path %r not found for %r" % (path, id))
continue
pptr = textures[path]
texture = pptr.resolve()
flipped = None
filename, exists = get_filename(args.outdir, orig_dir, id)
if not (args.skip_existing and exists):
print("-> %r" % (filename))
flipped = ImageOps.flip(texture.image).convert("RGB")
flipped.save(filename)
if values["tile"]:
filename, exists = get_filename(args.outdir, tiles_dir, id)
if not (args.skip_existing and exists):
tile_texture = generate_tile_image(texture.image, values["tile"])
print("-> %r" % (filename))
tile_texture.save(filename)
for sz in thumb_sizes:
thumb_dir = "%ix" % (sz)
filename, exists = get_filename(args.outdir, thumb_dir, id, ext=".jpg")
if not (args.skip_existing and exists):
if not flipped:
flipped = ImageOps.flip(texture.image).convert("RGB")
thumb_texture = flipped.resize((sz, sz))
print("-> %r" % (filename))
thumb_texture.save(filename)
def invertingAndCompare(problem, figures, options):
av_invert = ImageOps.flip(um.openAndInvert(figures[0]))
bv_invert = ImageOps.flip(um.openAndInvert(figures[1]))
ah_invert = ImageOps.mirror(um.openAndInvert(figures[0]))
dh_invert = ImageOps.mirror(um.openAndInvert(figures[3]))
aTog = um.measurePixelDifference(av_invert, um.openAndInvert(figures[6]))
bToh = um.measurePixelDifference(bv_invert, um.openAndInvert(figures[7]))
aToc = um.measurePixelDifference(ah_invert, um.openAndInvert(figures[2]))
dTof = um.measurePixelDifference(dh_invert, um.openAndInvert(figures[5]))
direction = um.determineDirection(aToc, dTof, aTog, bToh, figures)
return direction[1], um.searchForSolution(problem, direction[0], options)
def test_sanity():
ImageOps.autocontrast(lena("L"))
ImageOps.autocontrast(lena("RGB"))
ImageOps.autocontrast(lena("L"), cutoff=10)
ImageOps.autocontrast(lena("L"), ignore=[0, 255])
ImageOps.colorize(lena("L"), (0, 0, 0), (255, 255, 255))
ImageOps.colorize(lena("L"), "black", "white")
ImageOps.crop(lena("L"), 1)
ImageOps.crop(lena("RGB"), 1)
ImageOps.deform(lena("L"), deformer)
ImageOps.deform(lena("RGB"), deformer)
ImageOps.equalize(lena("L"))
ImageOps.equalize(lena("RGB"))
ImageOps.expand(lena("L"), 1)
ImageOps.expand(lena("RGB"), 1)
ImageOps.expand(lena("L"), 2, "blue")
ImageOps.expand(lena("RGB"), 2, "blue")
ImageOps.fit(lena("L"), (128, 128))
ImageOps.fit(lena("RGB"), (128, 128))
ImageOps.fit(lena("RGB").resize((1, 1)), (35, 35))
ImageOps.flip(lena("L"))
ImageOps.flip(lena("RGB"))
ImageOps.grayscale(lena("L"))
ImageOps.grayscale(lena("RGB"))
ImageOps.invert(lena("L"))
ImageOps.invert(lena("RGB"))
ImageOps.mirror(lena("L"))
ImageOps.mirror(lena("RGB"))
ImageOps.posterize(lena("L"), 4)
ImageOps.posterize(lena("RGB"), 4)
ImageOps.solarize(lena("L"))
ImageOps.solarize(lena("RGB"))
success()
def _get_image(overlay, x, y):
"""Superpose the picture of the timezone on the map"""
def _get_x_offset():
now = datetime.utcnow().timetuple()
return - int((now.tm_hour * 60 + now.tm_min - 12 * 60) / (24 * 60) * MAP_SIZE[0]) # night is centered at UTC noon (12)
im = BACK_IM.copy()
if overlay:
overlay_im = Image.open(TIMEZONE_RESOURCES + overlay)
im.paste(BACK_ENHANCED_IM, overlay_im)
night_im = ImageChops.offset(NIGHT_IM, _get_x_offset(), 0).crop(im.getbbox())
if IS_WINTER:
night_im = ImageOps.flip(night_im)
# In Wheezy alpha_composite and tobytes are not implemented, yet
try:
im.paste(Image.alpha_composite(night_im, LIGHTS_IM), night_im)
except:
im.paste(Image.blend(night_im, LIGHTS_IM, 0.5), night_im)
im.paste(DOT_IM, (int(x - DOT_IM.size[1] / 2), int(y - DOT_IM.size[0] / 2)), DOT_IM)
try:
data = im.tobytes()
w, h = im.size
data = GLib.Bytes.new(data)
pb = GdkPixbuf.Pixbuf.new_from_bytes(data, GdkPixbuf.Colorspace.RGB,
False, 8, w, h, w * 3)
return pb
except:
data = im.tostring()
w, h = im.size
pb = GdkPixbuf.Pixbuf.new_from_data(barr, GdkPixbuf.Colorspace.RGB,
False, 8, w, h, w * 3)
return pb
def get_render(self):
return np.asarray(\
ImageOps.flip(\
self.env.render('rgb_array')\
.convert('L')\
.resize((self.reduced_width, self.reduced_height), \
Image.BILINEAR)))
def load_image(self): """decode the image into a buffer""" self.image_data = Image.open(self.image_file) self.image_data = ImageOps.grayscale(self.image_data) if self.autocontrast: # may or may not improve the look of the transmitted spectrum self.image_data = ImageOps.autocontrast(self.image_data) if self.image_invert: # may or may not improve the look of the transmitted spectrum self.image_data = ImageOps.invert(self.image_data) if self.image_flip: # set to true for waterfalls that scroll from the top self.image_data = ImageOps.flip(self.image_data) (self.image_width, self.image_height) = self.image_data.size max_width = 4096.0 if self.image_width > max_width: scaling = max_width / self.image_width newsize = (int(self.image_width * scaling), int(self.image_height * scaling)) (self.image_width, self.image_height) = newsize self.image_data = self.image_data.resize(newsize) self.set_output_multiple(self.image_width) self.image_data = list(self.image_data.getdata()) if self.bt709_map: # scale brightness according to ITU-R BT.709 self.image_data = map( lambda x: x * 219 / 255 + 16, self.image_data) self.image_len = len(self.image_data) if self.repeatmode != 2: print "paint.image_source: %d bytes, %dpx width" % (self.image_len, self.image_width) self.line_num = 0
def wms_image(server, layers):
""" Retrieve and plot a WMS image.
Hard-coded for a single WMS server and PlateCarre() images.
Can plot on any projection"""
xlim = plt.gca().get_xlim()
ylim = plt.gca().get_ylim()
bbox = [xlim[0], ylim[0], xlim[1], ylim[1]]
# Construct the query string
request = server
request += "&version=1.1.0"
request += "&request=GetMap"
request += "&layers={}".format(layers)
request += "&bbox={}".format(",".join([str(i) for i in bbox]))
request += "&styles="
request += "&width={}&height={}".format(512, 512)
request += "&srs=EPSG:4326"
request += "&format=image/jpeg"
# Get jpeg from server.
jpeg_bytes = urllib2.urlopen(request).read()
pil_img = Image.open(StringIO.StringIO(jpeg_bytes))
pil_img = ImageOps.flip(pil_img)
# Turn the pil image into rgb array, to workaround a cartopy bug.
img_array = np.array(list(pil_img.getdata())).reshape((pil_img.size[0], pil_img.size[1], -1)) / 256.0
img_array = img_array.squeeze()
# Plot the platecaree image in the current plot projection.
plt.gca().imshow(img_array, origin="lower",
extent=[bbox[0], bbox[2], bbox[1], bbox[3]],
transform=ccrs.PlateCarree())
def apply_flip(pixbuf):
'''
image top to bottom
'''
width,height = pixbuf.get_width(),pixbuf.get_height()
y = ImageOps.flip(Image.frombytes(K.ImageConstants.RGB_SHORT_NAME,(width,height),pixbuf.get_pixels() ))
return I.fromImageToPixbuf(y)
def generate_tile_image(img, tile):
# tile the image horizontally (x2 is enough),
# some cards need to wrap around to create a bar (e.g. Muster for Battle),
# also discard alpha channel (e.g. Soulfire, Mortal Coil)
tiled = Image.new("RGB", (img.width * 2, img.height))
tiled.paste(img, (0, 0))
tiled.paste(img, (img.width, 0))
x, y, width, height = get_rect(
tile["m_TexEnvs"]["_MainTex"]["m_Offset"]["x"],
tile["m_TexEnvs"]["_MainTex"]["m_Offset"]["y"],
tile["m_TexEnvs"]["_MainTex"]["m_Scale"]["x"],
tile["m_TexEnvs"]["_MainTex"]["m_Scale"]["y"],
tile["m_Floats"].get("_OffsetX", 0.0),
tile["m_Floats"].get("_OffsetY", 0.0),
tile["m_Floats"].get("_Scale", 1.0),
img.width
)
bar = tiled.crop((x, y, x + width, y + height))
bar = ImageOps.flip(bar)
# negative x scale means horizontal flip
if tile["m_TexEnvs"]["_MainTex"]["m_Scale"]["x"] < 0:
bar = ImageOps.mirror(bar)
return bar.resize((OUT_WIDTH, OUT_HEIGHT), Image.LANCZOS)
def do_texture(path, id, textures, values, thumb_sizes, args):
print("Parsing %r (%r)" % (id, path))
if not path:
print("%r does not have a texture" % (id))
return
if path not in textures:
print("Path %r not found for %r" % (path, id))
return
pptr = textures[path]
texture = pptr.resolve()
flipped = None
filename, exists = get_filename(args.outdir, args.orig_dir, id, ext=".png")
if not (args.skip_existing and exists):
print("-> %r" % (filename))
flipped = ImageOps.flip(texture.image).convert("RGB")
flipped.save(filename)
for format in args.formats:
ext = "." + format
if not args.skip_tiles:
filename, exists = get_filename(args.outdir, args.tiles_dir, id, ext=ext)
if not (args.skip_existing and exists):
tile_texture = generate_tile_image(texture.image, values["tile"])
print("-> %r" % (filename))
tile_texture.save(filename)
if ext == ".png":
# skip png generation for thumbnails
continue
if args.skip_thumbnails:
# --skip-thumbnails was specified
continue
for sz in thumb_sizes:
thumb_dir = "%ix" % (sz)
filename, exists = get_filename(args.outdir, thumb_dir, id, ext=ext)
if not (args.skip_existing and exists):
if not flipped:
flipped = ImageOps.flip(texture.image).convert("RGB")
thumb_texture = flipped.resize((sz, sz))
print("-> %r" % (filename))
thumb_texture.save(filename)
def getframe(self):
if self.select_env == 'InvertedPendulum-v1': # for mujoco envs:
numpy_im = self.env.render('rgb_array') #this gives uint8 numpy array
im = Image.fromarray(numpy_im, 'RGB')
return np.asarray(im.convert('L').resize((self.dimO[0], self.dimO[1])), dtype= np.uint8)
im = self.env.render('rgb_array') # this gives uint8 numpy array
return np.asarray(ImageOps.flip(im.convert('L').resize((self.dimO[0], self.dimO[1]))))
def determineDirection(a, b, c, d, figures):
if min(a, b) > min(c, d):
result = ImageOps.mirror(openAndInvert(figures[6]))
optimal = min(a, b)
else:
result = ImageOps.flip(openAndInvert(figures[2]))
optimal = min(c, d)
return result, optimal
def handle_asset(asset, handle_formats):
for id, obj in asset.objects.items():
if obj.type not in handle_formats:
continue
d = obj.read()
if obj.type == "AudioClip":
if not d.data:
# eg. StreamedResource not available
continue
af = FSB5(d.data)
for i, sample in enumerate(af.samples):
if i > 0:
filename = "%s-%i.%s" % (d.name, i, af.get_sample_extension())
else:
filename = "%s.%s" % (d.name, af.get_sample_extension())
try:
sample = af.rebuild_sample(sample)
except ValueError as e:
print("WARNING: Could not extract %r (%s)" % (d, e))
continue
write_to_file(filename, sample, mode="wb")
elif obj.type == "MovieTexture":
filename = d.name + ".ogv"
write_to_file(filename, d.movie_data, mode="wb")
elif obj.type == "Shader":
write_to_file(d.name + ".cg", d.script)
elif obj.type == "Mesh":
try:
mesh_data = OBJMesh(d).export()
write_to_file(d.name + ".obj", mesh_data, mode="w")
except NotImplementedError as e:
print("WARNING: Could not extract %r (%s)" % (d, e))
mesh_data = pickle.dumps(d._obj)
write_to_file(d.name + ".Mesh.pickle", mesh_data, mode="wb")
elif obj.type == "TextAsset":
if isinstance(d.script, bytes):
write_to_file(d.name + ".bin", d.script, mode="wb")
else:
write_to_file(d.name + ".txt", d.script)
elif obj.type == "Texture2D":
filename = d.name + ".png"
image = d.image
if image is None:
print("WARNING: %s is an empty image" % (filename))
write_to_file(filename, "")
else:
print("Decoding %r" % (d))
img = ImageOps.flip(image)
path = get_output_path(filename)
img.save(path)
def process(self, image):
"""
@param image -- The image to process.
Returns a single image, or a list containing one or more images.
"""
BaseFilter.process(self, image)
newImage = ImageOps.flip(image)
return newImage
def modify_photo(image_data, film_size):
"""
Make the image grayscale and invert the colors
All manipulations for the original photo go here
"""
modified_image = ImageOps.grayscale(image_data)
# Image.ANTIALIAS is best for down sizing
modified_image = modified_image.resize(film_size, Image.ANTIALIAS)
modified_image = ImageOps.invert(modified_image)
modified_image = ImageOps.flip(modified_image)
return modified_image
def operations(self):
"""Perform enhancements from the ImageOps class. """
if self.effect == 'flip':
to_save = ImageOps.flip(self.image)
if self.effect == 'mirror':
to_save = ImageOps.mirror(self.image)
if self.effect == 'grayscale':
to_save = ImageOps.grayscale(self.image)
to_save.save(self.new_file)
return self.return_path
def draw_groups(groups, mcu, mem):
for n, group in enumerate(groups):
img = Image.new('RGBA', (XS, Y0), (0, 0, 0, 255))
drw = ImageDraw.Draw(img)
draw_boards(drw, mcu, mem)
for conn in group:
draw_conn(drw, conn)
img = ImageOps.flip(img)
img.save('%s.png' % n)
del drw
def flip_vertical(images, uv_pixel_positions):
"""
Fip the images and the pixel positions vertically (flip up/down)
See random_image_and_indices_mutation() for documentation of args and return types.
"""
mutated_images = [ImageOps.flip(image) for image in images]
v_pixel_positions = uv_pixel_positions[1]
mutated_v_pixel_positions = (image.height-1) - v_pixel_positions
mutated_uv_pixel_positions = (uv_pixel_positions[0], mutated_v_pixel_positions)
return mutated_images, mutated_uv_pixel_positions
def save_image(image_name='image'):
global n_image
glPixelStorei(GL_PACK_ALIGNMENT, 1)
width = width_GL
if nTextures == 2 :width = 2*width_GL
data = glReadPixels(0, 0, width, height_GL, GL_RGBA, GL_UNSIGNED_BYTE)
image = Image.frombytes("RGBA", (width, height_GL), data)
image = ImageOps.flip(image) # in my case image is flipped top-bottom for some reason
image_file_name = '{0}_{1}.png'.format(image_name, n_image)
image.save(image_file_name, 'PNG')
n_image += 1
print 'Image saved: {0}'.format(image_file_name)
def prepare_side_img(img, a, b):
(w, h) = img.size
p1 = [(0, h), (3*a, h), (0, h-3*a)] # first triangle
p2 = [(w, h), (w-3*a, h), (w, h-3*a)] # second one
mask = Image.new('L', (w, h), 255) # generate mask
ImageDraw.Draw(mask).polygon(p1, outline=1, fill=0)
ImageDraw.Draw(mask).polygon(p2, outline=1, fill=0)
output = ImageOps.fit(img, mask.size) # crop image
output.putalpha(mask) # put alpha to cropped part
return ImageOps.flip(output)
def applyflip(self, image): if self.rotationflip == 0: return image elif self.rotationflip == 1: return image.rotate(90) elif self.rotationflip == 2: return image.rotate(180) elif self.rotationflip == 3: return image.rotate(270) elif self.rotationflip == 4: return ImageOps.mirror(image) elif self.rotationflip == 5: return ImageOps.flip(image)
def upload_file():
global index
global cache_size
if request.method == 'POST':
err = False
if not 'width' in request.form:
print '%s%sDENY%s: The client did not specify a width.' % (timestamp(), FAIL, ENDC)
abort(500)
if not 'height' in request.form:
print '%s%sDENY%s: The client did not specify a height.' % (timestamp(), FAIL, ENDC)
abort(500)
if not 'img_data' in request.form:
print '%s%sDENY%s: The client did not specify any image data.' % (timestamp(), FAIL, ENDC)
abort(500)
if not 'Origin' in request.headers:
print '%s%sDENY%s: The client did not specify a CORS origin header.' % (timestamp(), FAIL, ENDC)
abort(500)
w = int(request.form['width'])
h = int(request.form['height'])
d = numpy.fromstring(request.form['img_data'][1:], dtype=numpy.uint8, sep=',');
fname = 'cache/%08d.png' % index
img = Image.frombuffer('RGB', [w,h], d, 'raw', 'RGB', 0, 1)
ImageOps.flip(img).save(fname)
cache_size = cache_size + os.path.getsize(fname)
index += 1
print '%s%sALLOW%s from %s%s%s frame %d (%d x %d), cache size = %s' % (timestamp(), OK, ENDC, BLUE, request.remote_addr, ENDC, index, w, h, sizeof_fmt(cache_size))
r = make_response('200')
r.headers['Access-Control-Allow-Origin'] = '*'
return r
def handle_asset(asset, handle_formats, dir, flip, objMesh):
for id, obj in asset.objects.items():
try:
otype = obj.type
except Exception as e:
error("[Error] %s" % (e))
continue
if otype not in handle_formats:
continue
d = obj.read()
save_path = os.path.join(dir, obj.type, d.name)
utils.make_dirs(save_path)
if otype == "Mesh":
try:
mesh_data = None
if not objMesh:
mesh_data = BabylonMesh(d).export()
utils.write_to_file(save_path + ".babylon", mesh_data, mode="w")
mesh_data = OBJMesh(d).export()
utils.write_to_file(save_path + ".obj", mesh_data, mode="w")
except (NotImplementedError, RuntimeError) as e:
error("WARNING: Could not extract %r (%s)" % (d, e))
mesh_data = pickle.dumps(d._obj)
utils.write_to_file(save_path + ".Mesh.pickle", mesh_data, mode="wb")
elif otype == "TextAsset":
if isinstance(d.script, bytes):
utils.write_to_file(save_path + ".bin", d.script, mode="wb")
else:
utils.write_to_file(save_path + ".txt", d.script)
elif otype == "Texture2D":
filename = d.name + ".png"
try:
image = d.image
if image is None:
info("WARNING: %s is an empty image" % (filename))
utils.write_to_file(save_path + ".empty", "")
else:
info("Decoding %r" % (d))
img = image
if flip:
img = ImageOps.flip(image)
img.save(save_path + ".png")
except Exception as e:
error("Failed to extract texture %s (%s)" % (d.name, e))
def _createMask(self, image, colorValue):
# Create mask of provided image
# (this method operates on numpy arrays) while typical _createMask
# method operates on PIL image. But that's still fine.
imgtemp=np.copy(image)
imgtemp[image==colorValue]=255
imgtemp[image!=colorValue]=0
# Convert numpy array into PIL image.
image = Image.fromarray(imgtemp.astype(np.uint8)).convert("L")
resizeTuple = self.renderingProperties['imageSize']
image = ImageOps.flip(image)
image = ImageChops.invert(image).resize(resizeTuple, Image.NEAREST)
return image
def _get_image(overlay, x, y):
"""Superpose the picture of the timezone on the map"""
def _get_x_offset():
now = datetime.utcnow().timetuple()
return - int((now.tm_hour*60 + now.tm_min - 12*60) / (24*60) * MAP_SIZE[0]) # night is centered at UTC noon (12)
im = BACK_IM.copy()
if overlay:
overlay_im = Image.open(TIMEZONE_RESOURCES + overlay)
im.paste(BACK_ENHANCED_IM, overlay_im)
night_im = ImageChops.offset(NIGHT_IM, _get_x_offset(), 0).crop(im.getbbox())
if IS_WINTER: night_im = ImageOps.flip(night_im)
im.paste(Image.alpha_composite(night_im, LIGHTS_IM), night_im)
im.paste(DOT_IM, (int(x - DOT_IM.size[1]/2), int(y - DOT_IM.size[0]/2)), DOT_IM)
return gtk.gdk.pixbuf_new_from_data(im.tobytes(), gtk.gdk.COLORSPACE_RGB,
False, 8, im.size[0], im.size[1], im.size[0] * 3)
def save_png(self, filename, data, scaling):
data, boundingBox = self.reposition(data, scaling)
im = Image.new('L', boundingBox, 255)
draw = ImageDraw.Draw(im)
for i in range(len(data) - 1):
draw.line(data[i] + data[i + 1], fill=128, width=5)
del draw
#Image origin is top left, convert to CAD-style bottom left
im = ImageOps.flip(im)
im.save(filename, "PNG")
def verticalReflection(image1, image2):
neg_image1 = convertImage(image1)
neg_image2 = convertImage(image2)
reflected_image1 = ImageOps.flip(neg_image1)
diff = ImageChops.difference(reflected_image1, neg_image2)
stat = ImageStat.Stat(diff)
mean = stat.mean[0]
if mean < 1.0:
print ("Vertical Reflection Function: Reflected Vertically")
return True
else:
print ("Vertical Reflection Function: Not reflected vertically")
return False
def test_snapshot_flip_with_ssim_check(cam, configer, snapshot):
# Test camera actually flip image after flip is enabled Check if image is
# set to flip correctly by comparing SSIM.
configer.set('video_c0_imprinttimestamp=0')
configer.set('video_c0_rotate=0&videoin_c0_mirror=0&videoin_c0_flip=0')
sleep(2)
option = {'resolution': '640x480'}
# take a snapshot
status, image = snapshot.take(option)
assert status, "Snapshot failed with resolution %s" % (option['resolution'])
# flip image
image_flip = image
image_flip_io = StringIO.StringIO()
image_flip = ImageOps.flip(image_flip)
image_flip.save(image_flip_io, format='jpeg')
image_flip_ref = scipy.misc.imread(image_flip_io, flatten=True).astype(numpy.float32)
# rotate
configer.set('videoin_c0_rotate=0&videoin_c0_mirror=0&videoin_c0_flip=1')
sleep(2)
# take another snapshot
status, image = snapshot.take(option)
assert status, "Snapshot failed with resolution %s" % (option['resolution'])
image_flip_cam = image
image_flip_cam_io = StringIO.StringIO()
image_flip_cam.save(image_flip_cam_io, format='jpeg')
image_flip_cam_ref = scipy.misc.imread(image_flip_cam_io, flatten=True).astype(numpy.float32)
ssim_exact = ssim.ssim_exact(image_flip_ref / 255, image_flip_cam_ref / 255)
print 'ssim (exact): %f' % ssim_exact
lower_bound = 0.700
if ssim_exact <= lower_bound:
image_flip.save('image-flip.jpg')
image_flip_cam.save('image-flip-cam.jpg')
assert ssim_exact > lower_bound, "SSIM too low. Image may not been flipped.\
Exp %f, Act %f" % (lower_bound, ssim_exact)
def voltearImagen(archivo):
imgVolteada = ImageOps.flip(archivo)
return imgVolteada
def build_feature_index(is_horizontal_banner=False,
resolution=None,
apply_flip=False,
apply_mirror=False):
pooling = "avg"
feature_filename = get_label_database_filename(pooling)
app_ids = list_app_ids(is_horizontal_banner=is_horizontal_banner)
num_games = len(app_ids)
target_model_size = get_target_model_size(resolution=resolution)
model = load_model(target_model_size=target_model_size, pooling=pooling)
preprocess = get_preprocessing_tool()
try:
Y_hat = np.load(feature_filename)
except FileNotFoundError:
num_features = get_num_features(model)
Y_hat = np.zeros((num_games, num_features))
start = time()
app_ids = sorted(app_ids, key=int)
freeze_app_ids(app_ids)
for (counter, app_id) in enumerate(app_ids):
# Avoid re-computing values of Y_hat which were previously computed and saved to disk, then recently loaded
if any(Y_hat[counter, :] != 0):
continue
image_filename = app_id_to_image_filename(app_id, is_horizontal_banner)
image = load_image(image_filename, target_size=target_model_size)
if apply_flip:
image = pil_imageops.flip(image)
if apply_mirror:
image = pil_imageops.mirror(image)
features = convert_image_to_features(image,
model,
preprocess=preprocess)
Y_hat[counter, :] = features
if (counter % 1000) == 0:
print("{}/{} in {:.2f} s".format(counter, num_games,
time() - start))
np.save(
feature_filename,
np.asarray(Y_hat, dtype=np.float16),
allow_pickle=False,
fix_imports=False,
)
np.save(
feature_filename,
np.asarray(Y_hat, dtype=np.float16),
allow_pickle=False,
fix_imports=False,
)
return
startingX = int(startingX)
startingY = input("Input initial Y-coordinate: ")
startingY = int(startingY)
Width = input("Input width of croped image")
Width = int(Width)
Height = input("Input height of croped image: ")
Height = int(Height)
img2 = img2.crop(box=(startingX, startingY, Width, Height))
img2.show()
# horizontal flipping
img3 = ImageOps.mirror(img3)
img3.show()
# vertical flipping
img4 = ImageOps.flip(img4)
img4.show()
# reading pixels & applying negative transformation
for i in range(0, img5.size[0] - 1):
for j in range(0, img5.size[1] - 1):
# geting pixel value at (x,y) position of the image
pixelColorVals = img5.getpixel((i, j))
# inverting color
redPixel = 255 - pixelColorVals[0]
# negate red pixel
greenPixel = 255 - pixelColorVals[1]
# negate green pixel
def twms_main(data):
"""
Do main TWMS work.
data - dictionary of params.
returns (error_code, content_type, resp)
"""
start_time = datetime.datetime.now()
content_type = "text/html"
resp = ""
srs = data.get("srs", "EPSG:4326")
gpx = data.get("gpx", "").split(",")
if gpx == ['']:
gpx = []
wkt = data.get("wkt", "")
trackblend = float(data.get("trackblend", "0.5"))
color = data.get("color", data.get("colour", "")).split(",")
track = False
tracks = []
if len(gpx) == 0:
req_bbox = projections.from4326(
(27.6518898, 53.8683186, 27.6581944, 53.8720359), srs)
else:
for g in gpx:
local_gpx = config.gpx_cache + "%s.gpx" % g
if not os.path.exists(config.gpx_cache):
os.makedirs(config.gpx_cache)
if not os.path.exists(local_gpx):
urllib.urlretrieve(
"http://www.openstreetmap.org/trace/%s/data" % g,
local_gpx)
if not track:
track = GPXParser(local_gpx)
req_bbox = projections.from4326(track.bbox, srs)
else:
track = GPXParser(local_gpx)
req_bbox = bbox.add(req_bbox,
projections.from4326(track.bbox, srs))
tracks.append(track)
req_type = data.get("request", "GetMap")
version = data.get("version", "1.1.1")
ref = data.get("ref", config.service_url)
if req_type == "GetCapabilities":
content_type, resp = capabilities.get(version, ref)
return (OK, content_type, resp)
layer = data.get("layers", config.default_layers).split(",")
if ("layers" in data) and not layer[0]:
layer = ["transparent"]
if req_type == "GetCorrections":
points = data.get("points", data.get("POINTS", "")).split("=")
resp = ""
points = [a.split(",") for a in points]
points = [(float(a[0]), float(a[1])) for a in points]
req.content_type = "text/plain"
for lay in layer:
for point in points:
resp += "%s,%s;" % tuple(
correctify.rectify(config.layers[lay], point))
resp += "\n"
return (OK, content_type, resp)
force = data.get("force", "")
if force != "":
force = force.split(",")
force = tuple(force)
filt = data.get("filt", "")
if filt != "":
filt = filt.split(",")
filt = tuple(filt)
if layer == [""]:
content_type = "text/html"
resp = overview.html(ref)
return (OK, content_type, resp)
format = data.get("format", config.default_format).lower()
format = formats.get("image/" + format, format)
format = formats.get(format, format)
if format not in formats.values():
return (ERROR, content_type, "Invalid format")
content_type = mimetypes[format]
width = 0
height = 0
resp_cache_path, resp_ext = "", ""
if req_type == "GetTile":
width = 256
height = 256
height = int(data.get("height", height))
width = int(data.get("width", width))
srs = data.get("srs", "EPSG:3857")
x = int(data.get("x", 0))
y = int(data.get("y", 0))
z = int(data.get("z", 1)) + 1
if "cache_tile_responses" in dir(config) and not wkt and (len(gpx)
== 0):
if (srs, tuple(layer), filt, width, height, force,
format) in config.cache_tile_responses:
resp_cache_path, resp_ext = config.cache_tile_responses[(
srs, tuple(layer), filt, width, height, force, format)]
resp_cache_path = resp_cache_path + "/%s/%s/%s.%s" % (
z - 1, x, y, resp_ext)
if os.path.exists(resp_cache_path):
return (OK, content_type, open(resp_cache_path,
"r").read())
if len(layer) == 1:
if layer[0] in config.layers:
if config.layers[layer[0]][
"proj"] == srs and width is 256 and height is 256 and not filt and not force and not correctify.has_corrections(
config.layers[layer[0]]):
local = config.tiles_cache + config.layers[
layer[0]]["prefix"] + "/z%s/%s/x%s/%s/y%s." % (
z, x / 1024, x, y / 1024, y)
ext = config.layers[layer]["ext"]
adds = ["", "ups."]
for add in adds:
if os.path.exists(local + add + ext):
tile_file = open(local + add + ext, "r")
resp = tile_file.read()
return (OK, content_type, resp)
req_bbox = projections.from4326(projections.bbox_by_tile(z, x, y, srs),
srs)
if data.get("bbox", None):
req_bbox = tuple(map(float, data.get("bbox", req_bbox).split(",")))
req_bbox = projections.to4326(req_bbox, srs)
req_bbox, flip_h = bbox.normalize(req_bbox)
box = req_bbox
#print >> sys.stderr, req_bbox
#sys.stderr.flush()
height = int(data.get("height", height))
width = int(data.get("width", width))
width = min(width, config.max_width)
height = min(height, config.max_height)
if (width == 0) and (height == 0):
width = 350
# layer = layer.split(",")
imgs = 1.
ll = layer.pop(0)
if ll[-2:] == "!c":
ll = ll[:-2]
if wkt:
wkt = "," + wkt
wkt = correctify.corr_wkt(config.layers[ll]) + wkt
srs = config.layers[ll]["proj"]
try:
result_img = getimg(box, srs, (height, width), config.layers[ll],
start_time, force)
except KeyError:
result_img = Image.new("RGBA", (width, height))
#width, height = result_img.size
for ll in layer:
if ll[-2:] == "!c":
ll = ll[:-2]
if wkt:
wkt = "," + wkt
wkt = correctify.corr_wkt(config.layers[ll]) + wkt
srs = config.layers[ll]["proj"]
im2 = getimg(box, srs, (height, width), config.layers[ll], start_time,
force)
if "empty_color" in config.layers[ll]:
ec = ImageColor.getcolor(config.layers[ll]["empty_color"], "RGBA")
sec = set(ec)
if "empty_color_delta" in config.layers[ll]:
delta = config.layers[ll]["empty_color_delta"]
for tr in range(-delta, delta):
for tg in range(-delta, delta):
for tb in range(-delta, delta):
if (ec[0] + tr) >= 0 and (ec[0] + tr) < 256 and (
ec[1] + tr
) >= 0 and (ec[1] + tr) < 256 and (
ec[2] + tr) >= 0 and (ec[2] + tr) < 256:
sec.add((ec[0] + tr, ec[1] + tg, ec[2] + tb,
ec[3]))
i2l = im2.load()
for x in range(0, im2.size[0]):
for y in range(0, im2.size[1]):
t = i2l[x, y]
if t in sec:
i2l[x, y] = (t[0], t[1], t[2], 0)
if not im2.size == result_img.size:
im2 = im2.resize(result_img.size, Image.ANTIALIAS)
im2 = Image.composite(im2, result_img,
im2.split()[3]) # imgs/(imgs+1.))
if "noblend" in force:
result_img = im2
else:
result_img = Image.blend(im2, result_img, 0.5)
imgs += 1.
##Applying filters
result_img = filter.raster(result_img, filt, req_bbox, srs)
#print >> sys.stderr, wkt
#sys.stderr.flush()
if wkt:
result_img = drawing.wkt(wkt, result_img, req_bbox, srs,
color if len(color) > 0 else None, trackblend)
if len(gpx) > 0:
last_color = None
c = iter(color)
for track in tracks:
try:
last_color = c.next()
except StopIteration:
pass
result_img = drawing.gpx(track, result_img, req_bbox, srs,
last_color, trackblend)
if flip_h:
result_img = ImageOps.flip(result_img)
image_content = StringIO.StringIO()
if format == "JPEG":
try:
result_img.save(image_content,
format,
quality=config.output_quality,
progressive=config.output_progressive)
except IOError:
result_img.save(image_content,
format,
quality=config.output_quality)
elif format == "PNG":
result_img.save(image_content,
format,
progressive=config.output_progressive,
optimize=config.output_optimize)
elif format == "GIF":
result_img.save(image_content,
format,
quality=config.output_quality,
progressive=config.output_progressive)
else: ## workaround for GIF
result_img = result_img.convert("RGB")
result_img.save(image_content,
format,
quality=config.output_quality,
progressive=config.output_progressive)
resp = image_content.getvalue()
if resp_cache_path:
try:
"trying to create local cache directory, if it doesn't exist"
os.makedirs("/".join(resp_cache_path.split("/")[:-1]))
except OSError:
pass
try:
a = open(resp_cache_path, "w")
a.write(resp)
a.close()
except (OSError, IOError):
print >> sys.stderr, "error saving response answer to file %s." % (
resp_cache_path)
sys.stderr.flush()
return (OK, content_type, resp)
def _image_callback(self, msg):
self.pil_image = imgmsg_to_pil(msg)
if hasattr(self, 'display_flip') and self.display_flip:
self.pil_image = ImageOps.flip(self.pil_image)
self.pil_image = ImageOps.mirror(self.pil_image)
self.cv_image = cv2.resize(pil_to_cv(self.pil_image), dsize=(300, 300))
def imageBorder(img, thickness, edgeFill="#ffffff00"):
"""
Add a border of thickness pixels around the image
:param img: the image to add a border to can be pil image, numpy array, or whatever
:param thickness: the border thickness in pixels. Can be:
int - border all the way around
(w_border,h_border) - add border this big to each side
(x,y,x2,y2) - add border this big to each side
:param edgeFill: defines how to extend. It can be:
mirror - reflect the pixels leading up to the border
repeat - repeat the image over again (useful with repeating textures)
clamp - streak last pixels out to edge
[background color] - simply fill with the given color
TODO: combine into extendImageCanvas function
"""
if not isinstance(thickness, (tuple, list)):
thickness = (thickness, thickness, thickness, thickness)
elif len(thickness) == 2:
thickness = (thickness[0], thickness[1], thickness[0], thickness[1])
thickness = [int(t) for t in thickness]
img = imageRepr.pilImage(img)
newSize = (int(img.size[0] + thickness[0] + thickness[2]),
int(img.size[1] + thickness[1] + thickness[3]))
if edgeFill == 'mirror':
newImage = Image.new(img.mode, newSize)
# top
fill = ImageOps.flip(img.crop((0, 0, img.width, thickness[1])))
newImage.paste(fill, (thickness[1], 0))
# bottom
fill = ImageOps.flip(
img.crop((0, img.height - thickness[2], img.width, img.height)))
newImage.paste(fill, (thickness[2], img.height + thickness[2]))
# left
fill = ImageOps.mirror(img.crop((0, 0, thickness[0], img.height)))
newImage.paste(fill, (0, thickness[0]))
# right
fill = ImageOps.mirror(
img.crop((img.width - thickness[3], 0, img.width, img.height)))
newImage.paste(fill, (img.width + thickness[3], thickness[3]))
# top-left corner
#fill=ImageOps.mirror(ImageOps.flip(img.crop((0,0,thickness,thickness))))
#newImage.paste(fill,(0,0))
# top-right corner
#fill=ImageOps.mirror(ImageOps.flip(img.crop((img.width-thickness,0,img.width,thickness))))
#newImage.paste(fill,(img.width+thickness,0))
# bottom-left corner
#fill=ImageOps.mirror(ImageOps.flip(img.crop((0,img.height-thickness,thickness,img.height))))
#newImage.paste(fill,(0,img.height+thickness))
# bottom-right corner
#fill=ImageOps.mirror(ImageOps.flip(img.crop((img.width-thickness,img.height-thickness,img.width,img.height))))
#newImage.paste(fill,(img.width+thickness,img.height+thickness))
elif edgeFill == 'repeat':
newImage = Image.new(img.mode, newSize)
# top
fill = img.crop((0, 0, img.width, thickness[1]))
newImage.paste(fill, (thickness[1], img.height + thickness[1]))
# bottom
fill = img.crop((0, img.height - thickness[2], img.width, img.height))
newImage.paste(fill, (thickness[2], 0))
# left
fill = img.crop((0, 0, thickness[0], img.height))
newImage.paste(fill, (img.width + thickness[0], thickness[0]))
# right
fill = img.crop((img.width - thickness[3], 0, img.width, img.height))
newImage.paste(fill, (0, thickness[3]))
# top-left corner
fill = img.crop((0, 0, thickness, thickness))
newImage.paste(fill, (img.width + thickness, img.height + thickness))
# top-right corner
fill = img.crop((img.width - thickness, 0, img.width, thickness))
newImage.paste(fill, (0, img.height + thickness))
# bottom-left corner
fill = img.crop((0, img.height - thickness, thickness, img.height))
newImage.paste(fill, (img.width + thickness, 0))
# bottom-right corner
fill = img.crop((img.width - thickness, img.height - thickness,
img.width, img.height))
newImage.paste(fill, (0, 0))
elif edgeFill == 'clamp':
newImage = Image.new(img.mode, newSize)
# top
fill = img.crop((0, 0, img.width, 1)).resize((img.width, thickness[1]),
resample=Image.NEAREST)
newImage.paste(fill, (thickness[1], 0))
# bottom
fill = img.crop((0, img.height - 1, img.width, img.height)).resize(
(img.width, thickness[2]), resample=Image.NEAREST)
newImage.paste(fill, (thickness[2], img.height + thickness[2]))
# left
fill = img.crop((0, 0, 1, img.height)).resize(
(thickness[0], img.height), resample=Image.NEAREST)
newImage.paste(fill, (0, thickness[0]))
# right
fill = img.crop((img.width - 1, 0, img.width, img.height)).resize(
(thickness[3], img.height), resample=Image.NEAREST)
newImage.paste(fill, (img.width + thickness[3], thickness[3]))
# TODO: corners
# top-left corner
fill = img.crop((0, 0, 1, 1)).resize((thickness, thickness),
resample=Image.NEAREST)
newImage.paste(fill, (0, 0))
# top-right corner
fill = img.crop((img.width - 1, 0, img.width, 1)).resize(
(thickness, thickness), resample=Image.NEAREST)
newImage.paste(fill, (img.width + thickness, 0))
# bottom-left corner
fill = img.crop((0, img.height - 1, 1, img.height)).resize(
(thickness, thickness), resample=Image.NEAREST)
newImage.paste(fill, (0, img.height + thickness))
# bottom-right corner
fill = img.crop(
(img.width - 1, img.height - 1, img.width, img.height)).resize(
(thickness, thickness), resample=Image.NEAREST)
newImage.paste(fill, (img.width + thickness, img.height + thickness))
else:
newImage = Image.new(img.mode, newSize, edgeFill)
# splat the original image in the middle
if True:
if newImage.mode.endswith('A'):
newImage.alpha_composite(img, dest=(thickness[0], thickness[1]))
else:
newImage.paste(img, (thickness[0], thickness[1]))
return newImage
if __name__ == '__main__':
width = 699
height = 699
img = Image.new('RGB', (width+1, height+1), "black") # create a new black image
pixels = img.load()
model = Model('african_head.obj')
light_dir = Point3d(0, 0, -1)
for face in model.faces:
len_face = len(face)
triangle_coords = []
world_coords = []
for j in range(len_face):
v0 = model.verts[face[j]]
v1 = model.verts[face[(j+1) % len_face]]
x0 = (v0.x+1.) * width/2
y0 = (v0.y+1.) * height/2
triangle_coords.append([int(x0), int(y0)])
world_coords.append(v0)
v1 = vect3d_minus(world_coords[2], world_coords[0])
v2 = vect3d_minus(world_coords[1], world_coords[0])
normal = normalize(cross_product(v1, v2))
intencity = vect3d_mult(normal, light_dir)
if intencity > 0:
triangle(triangle_coords[0], triangle_coords[1], triangle_coords[2], pixels, gray_intencify(intencity))
ImageOps.flip(img).show()
def flip(self):
return ImageOps.flip(self.image)
def makepilimage(self, scale="log", negative=False):
"""
Makes a PIL image out of the array, respecting the z1 and z2 cutoffs.
By default we use a log scaling identical to iraf's, and produce an image of mode "L", i.e. grayscale.
But some drawings or colourscales will change the mode to "RGB" later, if you choose your own colours.
If you choose scale = "clog" or "clin", you get hue values (aka rainbow colours).
"""
calcarray = self.numpyarray.transpose()
if scale == "log" or scale == "lin":
self.negative = negative
# numpyarrayshape = self.numpyarray.shape
# calcarray.ravel() # does not change in place in fact !
calcarray = calcarray.clip(min=self.z1, max=self.z2)
if scale == "log":
# calcarray = np.array(map(lambda x: loggray(x, self.z1, self.z2), calcarray))
calcarray = loggray(calcarray, self.z1, self.z2)
else:
# calcarray = np.array(map(lambda x: lingray(x, self.z1, self.z2), calcarray))
calcarray = lingray(calcarray, self.z1, self.z2)
# calcarray.shape = numpyarrayshape
bwarray = np.zeros(calcarray.shape)
calcarray.round(out=bwarray)
bwarray = bwarray.astype(
np.uint8) # and you get the dtype you want in the end
if negative:
if self.verbose:
print "Using negative scale"
bwarray = 255 - bwarray
if self.verbose:
print "PIL range : [%i, %i]" % (np.min(bwarray),
np.max(bwarray))
# We flip it so that (0, 0) is back in the bottom left corner as in ds9
# We do this here, so that you can write on the image from left to right :-)
self.pilimage = imop.flip(im.fromarray(bwarray))
if self.verbose:
print "PIL image made with scale : %s" % scale
return 0
if scale == "clog" or scale == "clin": # Rainbow !
self.negative = False
if scale == "clin":
calcarray = (calcarray.clip(min=self.z1, max=self.z2) -
self.z1) / (self.z2 - self.z1) # 0 to 1
if scale == "clog":
calcarray = 10.0 + 990.0 * (
calcarray.clip(min=self.z1, max=self.z2) - self.z1) / (
self.z2 - self.z1) # 10 to 1000
calcarray = (np.log10(calcarray) - 1.0) * 0.5 # 0 to 1
(rarray, garray, barray) = rainbow(calcarray, autoscale=False)
carray = np.dstack((rarray, garray, barray))
self.pilimage = imop.flip(im.fromarray(carray, "RGB"))
if self.verbose:
print "PIL image made with scale : %s" % scale
return 0
raise RuntimeError, "I don't know your colourscale, choose lin log clin or clog !"
def transform(self, i, image):
# (_x, _y): random translation position
_x = np.random.randint(0, self.x)
_y = np.random.randint(0, self.y)
# _angle : random rotation angle
_angle = np.random.randint(0, self.angle)
minw = float(image.width) * float(self.shrink_rw)
minh = float(image.height)* float(self.shrink_rh)
# (_w, _h) : random image_width and image_height
self._w = int( np.random.randint(int(minw), image.width) )
self._h = int( np.random.randint(int(minh), image.height) )
print(" {} {} {} {}".format(_x, _y, self._w, self._h))
if i % 3 == 0:
_angle = _angle * (-1)
# Resize the image to (_w, _h)
image = image.resize(size=(self._w, self._h), resample=Image.LANCZOS)
# Rotate the image by _angle
image = image.rotate(_angle, translate=(_x, _y), expand=True)
if i % 3 == 0:
print("CONTRAST {}".format(i))
image = ImageOps.autocontrast(image, self.contrast)
if i % 4 == 0 and self.vflip == True:
print("VERTICAL FLIP {}".format(i))
image = ImageOps.flip(image)
if i % 5 == 0 and self.hflip == True:
print("HORIZONTAL FLIP {}".format(i))
image = ImageOps.mirror(image)
if i % 5 == 0:
# Apply a simple AFFINE transformation to the image.
xshift = int( abs(self.xshift) * self.width )
yshift = int( abs(self.yshift) * self.height )
# New width and height (_nw, _nh) for AFFINE transformation
_nw = self._w + xshift
_nh = self._h + yshift
# Very simple coefficients fo AFFINE transformation
coeffs = (1, self.xshift, 0, 0, 1, 0, 0, 0)
# Inverting _xs flag.
self.xshift = self.xshift * (-1)
print("AFFINE {}".format(i))
image = image.transform((_nw, _nh), Image.AFFINE, coeffs, Image.BICUBIC)
if i % 6 == 0 and self.sharpen == True:
print("SHARPEN {}".format(i))
image = image.filter(ImageFilter.SHARPEN)
if i % 8 == 0 and self.smooth == True:
print("SMOOTH_MORE {}".format(i))
image = image.filter(ImageFilter.SMOOTH_MORE)
if i % 9 == 0 and self.edge_enhance == True:
print("EDGE_ENHANCE_MORE {}".format(i))
image = image.filter(ImageFilter.EDGE_ENHANCE_MORE)
if i>0 and i % 11 == 0 and self.noise >0.0:
print("NOISE {}".format(i))
image = self.inject_saultpepper_noise(image)
return image
def _draw_image(self, gcode, include_rapids):
# size of the image (should be based on the max path point)
scale = self._image_size()
if self.transparency:
img = Image.new('RGBA', self.image_size, (255, 0, 0, 0))
else:
img = Image.new('RGB', self.image_size, self.background)
draw = ImageDraw.Draw(img)
# draw centreline
cl_y = (self.image_size[1] / 2 - self._min_y)
start = (self.margin * 0.25, cl_y)
end = (self.image_size[0] - self.margin * 0.5, cl_y)
draw.line([start, end],
fill=(252, 226, 5),
width=self.line_thickness * 2)
for idx, command in enumerate(gcode):
if idx < len(gcode) - 1:
movement = command.get_movement()
if movement not in ["G0", "G1", "G2", "G3"]:
continue
if movement == "G0" and not include_rapids:
continue
params = command.get_params()
prev_params = gcode[idx - 1].get_params()
line_colour = self._get_line_colour(movement)
x_start = (prev_params['Z'] -
self._min_x) * scale + self.margin / 2
y_start = (prev_params['X'] -
self._min_y) * scale + self.margin / 2
x_end = (params['Z'] - self._min_x) * scale + self.margin / 2
y_end = (params['X'] - self._min_y) * scale + self.margin / 2
if movement in ["G0", "G1"]:
draw.line([(x_start, y_start), (x_end, y_end)],
fill=line_colour,
width=self.line_thickness)
if movement in ["G2", "G3"]:
x_centre = (prev_params['Z'] + params['K'] -
self._min_x) * scale + self.margin / 2
y_centre = (prev_params['X'] + params['I'] -
self._min_y) * scale + self.margin / 2
distance = self._get_distance(x_centre, y_centre, x_start,
y_start)
start_angle = self._get_angle(x_centre, y_centre, x_start,
y_start)
end_angle = self._get_angle(x_centre, y_centre, x_end,
y_end)
boundbox = [(x_centre - distance, y_centre - distance),
(x_centre + distance, y_centre + distance)]
if movement == "G2":
draw.arc(boundbox,
end_angle,
start_angle,
fill=line_colour,
width=self.line_thickness)
if movement == "G3":
draw.arc(boundbox,
start_angle,
end_angle,
fill=line_colour,
width=self.line_thickness)
# Mirror because its draw flipped.
if self.mirror_image:
img = ImageOps.mirror(img)
elif self.flip_image:
img = ImageOps.flip(img)
else:
img = ImageOps.flip(img)
if self.transparency:
img.save(self.file_location + self.image_name + '.png')
else:
img.save(self.file_location + self.image_name + self.image_type)
def __getitem__(self, index):
# Arrange frames
folder_id = int(str(self.input_list[index])[-9:-7])
num_input = len(self.input_list)
num_gt = len(self.gt_list)
if num_input != num_gt:
raise ValueError("wrong dataset")
if index == (len(self.input_list) - 1):
folder_id_next = None
folder_id_next_next = None
elif index == (len(self.input_list) - 2):
folder_id_next = int(str(self.input_list[index + 1])[-9:-7])
folder_id_next_next = None
else:
folder_id_next = int(str(self.input_list[index + 1])[-9:-7])
folder_id_next_next = int(str(self.input_list[index + 2])[-9:-7])
if index == 0:
folder_id_previous = None
folder_id_previous_previous = None
elif index == 1:
folder_id_previous = int(str(self.input_list[index - 1])[-9:-7])
folder_id_previous_previous = None
else:
folder_id_previous = int(str(self.input_list[index - 1])[-9:-7])
folder_id_previous_previous = int(
str(self.input_list[index - 2])[-9:-7])
# Get image ID
interval = 1
if self.frames == 5:
if folder_id != folder_id_previous:
self.input_frame_lists = [
index, index, index, index + interval, index + interval * 2
] # [n, n, n, n+1, n+2]
self.seg_frame_lists = [
index, index, index, index + interval, index + interval * 2
]
self.gt_frame_lists = [index, index, index + interval]
self.input1_frame_lists = self.input_frame_lists
elif folder_id == folder_id_previous and folder_id != folder_id_previous_previous:
self.input_frame_lists = [
index - interval, index - interval, index,
index + interval, index + interval * 2
] # [n-1, n-1, n, n+1, n+2]
self.seg_frame_lists = [
index - interval, index - interval, index,
index + interval, index + interval * 2
]
self.gt_frame_lists = [
index - interval, index, index + interval
]
self.input1_frame_lists = self.input_frame_lists
elif folder_id != folder_id_next:
self.input_frame_lists = [
index - interval * 2, index - interval, index, index, index
] # [n-2, n-1, n, n, n]
self.seg_frame_lists = [
index - interval * 2, index - interval, index, index, index
]
self.gt_frame_lists = [index - interval, index, index]
self.input1_frame_lists = self.input_frame_lists
elif folder_id == folder_id_next and folder_id != folder_id_next_next:
self.input_frame_lists = [
index - interval * 2, index - interval, index,
index + interval, index + interval
] # [n-2, n-1, n, n+1, n+1]
self.seg_frame_lists = [
index - interval * 2, index - interval, index,
index + interval, index + interval
]
self.gt_frame_lists = [
index - interval, index, index + interval
]
self.input1_frame_lists = self.input_frame_lists
else:
self.input_frame_lists = [
index - interval * 2, index - interval, index,
index + interval, index + interval * 2
]
self.seg_frame_lists = [
index - interval * 2, index - interval, index,
index + interval, index + interval * 2
] # [n-2, n-1, n, n+1, n+2]
self.gt_frame_lists = [
index - interval, index, index + interval
]
self.input1_frame_lists = self.input_frame_lists
elif self.frames == 3:
if folder_id != folder_id_previous:
self.frame_lists = [index, index, index + interval]
elif folder_id != folder_id_next:
self.frame_lists = [index - interval, index, index]
elif index == (len(self.input_list) - 1):
self.frame_lists = [index - interval, index, index]
else:
self.frame_lists = [index - interval, index, index + interval]
elif self.frames == 1:
self.frame_lists = [index]
else:
raise ValueError("only support frames == 1 & 3 & 5")
# Open images
input_imgs = [
Image.open((self.input_list[i])).convert('RGB')
for i in self.input_frame_lists
]
input1_imgs = [
Image.open((self.input1_list[i])).convert('RGB')
for i in self.input1_frame_lists
]
gt_imgs = [
Image.open((self.gt_list[i])).convert('RGB')
for i in self.gt_frame_lists
] #.convert('L')
seg_imgs = [
Image.open((self.seg_list[i])).convert('L')
for i in self.seg_frame_lists
]
# Set parameters
left_top_w = random.randint(0, gt_imgs[0].size[0] - self.fineSize - 1)
left_top_h = random.randint(0, gt_imgs[0].size[1] - self.fineSize - 1)
random_flip_h = random.random()
random_flip_v = random.random()
random_rot = random.random()
seg = []
for seg_img in seg_imgs:
input_patch = seg_img.crop(
(left_top_w, left_top_h, left_top_w + self.fineSize,
left_top_h + self.fineSize))
input_patch = input_patch.resize((self.cropSize, self.cropSize),
Image.BICUBIC)
if random_flip_h < 0.5:
input_patch = ImageOps.flip(input_patch)
if random_flip_v < 0.5:
input_patch = ImageOps.mirror(input_patch)
if random_rot < 0.5:
input_patch = input_patch.rotate(180)
input_patch = np.array(input_patch, dtype=np.float32) / 255
# input_patch = input_patch.transpose((2, 0, 1))
input_patch = torch.from_numpy(input_patch.copy()).float()
input_patch = torch.unsqueeze(input_patch, 0)
seg.append(input_patch)
seg = torch.cat(seg, 0)
seg = np.array(seg, dtype=np.float32)
gts = []
for gt_img in gt_imgs:
input_patch = gt_img.crop(
(left_top_w, left_top_h, left_top_w + self.fineSize,
left_top_h + self.fineSize))
input_patch = input_patch.resize((self.cropSize, self.cropSize),
Image.BICUBIC)
if random_flip_h < 0.5:
input_patch = ImageOps.flip(input_patch)
if random_flip_v < 0.5:
input_patch = ImageOps.mirror(input_patch)
if random_rot < 0.5:
input_patch = input_patch.rotate(180)
input_patch = np.array(input_patch, dtype=np.float32) / 255
input_patch = input_patch.transpose((2, 0, 1))
input_patch = torch.from_numpy(input_patch.copy()).float()
#nomalize = transforms.Normalize(mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
#input_patch = nomalize(input_patch)
#input_patch = torch.unsqueeze(input_patch, 0)
gts.append(input_patch)
gts = torch.cat(gts, 0)
gts = np.array(gts, dtype=np.float32)
# Processing input images
inputs = []
for input_img in input_imgs:
input_patch = input_img.crop(
(left_top_w, left_top_h, left_top_w + self.fineSize,
left_top_h + self.fineSize))
input_patch = input_patch.resize((self.cropSize, self.cropSize),
Image.BICUBIC)
if random_flip_h < 0.5:
input_patch = ImageOps.flip(input_patch)
if random_flip_v < 0.5:
input_patch = ImageOps.mirror(input_patch)
if random_rot < 0.5:
input_patch = input_patch.rotate(180)
input_patch = np.array(input_patch, dtype=np.float32) / 255
input_patch = input_patch.transpose((2, 0, 1))
input_patch = torch.from_numpy(input_patch.copy()).float()
# nomalize = transforms.Normalize(mean=(0.5,0.5,0.5), std=(0.5,0.5,0.5))
# input_patch = nomalize(input_patch)
inputs.append(input_patch)
inputs = torch.cat(inputs, 0)
inputs = np.array(inputs, dtype=np.float32)
inputs1 = []
for input1_img in input1_imgs:
input_patch = input1_img.crop(
(left_top_w, left_top_h, left_top_w + self.fineSize,
left_top_h + self.fineSize))
input_patch = input_patch.resize((self.cropSize, self.cropSize),
Image.BICUBIC)
if random_flip_h < 0.5:
input_patch = ImageOps.flip(input_patch)
if random_flip_v < 0.5:
input_patch = ImageOps.mirror(input_patch)
if random_rot < 0.5:
input_patch = input_patch.rotate(180)
input_patch = np.array(input_patch, dtype=np.float32) / 255
input_patch = input_patch.transpose((2, 0, 1))
input_patch = torch.from_numpy(input_patch.copy()).float()
inputs1.append(input_patch)
inputs1 = torch.cat(inputs1, 0)
inputs1 = np.array(inputs1, dtype=np.float32)
# Processing gt image
# gt_patch = gt_img.crop(
# (left_top_w, left_top_h, left_top_w + self.fineSize, left_top_h + self.fineSize))
# gt_patch = gt_patch.resize((self.cropSize, self.cropSize), Image.BICUBIC)
# if random_flip_h < 0.5:
# gt_patch = ImageOps.flip(gt_patch)
# if random_flip_v < 0.5:
# gt_patch = ImageOps.mirror(gt_patch)
# if random_rot < 0.5:
# gt_patch = gt_patch.rotate(180)
# gt_patch = np.array(gt_patch, dtype=np.float32) / 255
# gt_patch = gt_patch.transpose((2, 0, 1))
return inputs.copy(), \
gts.copy(), \
seg.copy(),\
inputs1.copy()
def got_clipboard_lock():
if COMPRESSED_IMAGES:
fmt_name = LPCSTR(img_format.upper().encode("latin1") +
b"\0") #ie: "PNG"
fmt = RegisterClipboardFormatA(fmt_name)
if fmt:
data_handle = GetClipboardData(fmt)
if data_handle:
size = GlobalSize(data_handle)
data = GlobalLock(data_handle)
log("GetClipboardData(%s)=%#x size=%s, data=%#x",
img_format.upper(), data_handle, size, data)
if data and size:
try:
cdata = (c_char * size).from_address(data)
finally:
GlobalUnlock(data)
got_image(bytes(cdata), False)
return True
data_handle = GetClipboardData(win32con.CF_DIBV5)
log("CF_BITMAP=%s", data_handle)
data = GlobalLock(data_handle)
if not data:
log("failed to lock data handle %#x (may try again)",
data_handle)
return False
try:
header = cast(data, PBITMAPV5HEADER).contents
offset = header.bV5Size + header.bV5ClrUsed * 4
w, h = header.bV5Width, abs(header.bV5Height)
bits = header.bV5BitCount
log(
"offset=%s, width=%i, height=%i, compression=%s", offset,
w, h,
BI_FORMATS.get(header.bV5Compression,
header.bV5Compression))
log("planes=%i, bitcount=%i", header.bV5Planes, bits)
log("colorspace=%s",
COLOR_PROFILES.get(header.bV5CSType, header.bV5CSType))
#if header.bV5Compression in (BI_JPEG, BI_PNG):
# pass
if header.bV5Compression != BI_RGB:
errback(
"cannot handle %s compression yet" % BI_FORMATS.get(
header.bV5Compression, header.bV5Compression))
return True
if bits == 24:
save_format = "RGB"
rgb_format = "BGR"
stride = roundup(w * 3, 4)
elif bits == 32:
save_format = "RGBA"
rgb_format = "BGRA"
stride = w * 4
else:
errback(
"cannot handle image data with %i bits per pixel yet" %
bits)
return True
img_size = stride * h
rgb_data = (c_char * img_size).from_address(data + offset)
from PIL import Image, ImageOps
img = Image.frombytes(save_format, (w, h), rgb_data, "raw",
rgb_format, stride, 1)
if header.bV5Height > 0:
img = ImageOps.flip(img)
buf = BytesIO()
img.save(buf, format=save_format)
data = buf.getvalue()
buf.close()
got_image(data, True)
return True
finally:
GlobalUnlock(data)
def kaleidoscope(triangle_width, infile, outfile):
triangle_height = int(triangle_width * numpy.sqrt(3) / 2)
img = Image.open(infile).convert('RGBA')
width, height = img.size
print(width, height)
centre_point = (width / 2, height / 2)
print("Centre:", centre_point)
top_of_triangle = (height / 2) - (triangle_height / 2)
print(top_of_triangle)
bottom_of_triangle = top_of_triangle + triangle_height
left_of_triangle = (width / 2) - (triangle_width / 2)
right_of_triangle = left_of_triangle + triangle_width
print("Top:", top_of_triangle)
print("Bottom:", bottom_of_triangle)
print("Left:", left_of_triangle)
print("Right:", right_of_triangle)
# Triangle zero
a = (centre_point[0], top_of_triangle)
b = (right_of_triangle, bottom_of_triangle)
c = (left_of_triangle, bottom_of_triangle)
print(a, b, c)
# x is leftmost point of next triangle
x = centre_point[0]
i = 0
tri1 = [a, b, c]
new_a = a
new_b = b
new_c = c
# (Every third image is a vertical flip, so an optimisation would be to
# calculate just the three rotated triangles and paste flips as needed.
# These three flips could also be cached.)
# Fill to the right
print("Fill to the right")
while (x < width):
i += 1
print(i, x, width)
if is_odd(i):
new_y = top_of_triangle
else:
new_y = bottom_of_triangle
if i % 3 == 1:
new_c = (new_c[0] + (1.5 * triangle_width), new_y)
elif i % 3 == 2:
new_a = (new_a[0] + (1.5 * triangle_width), new_y)
elif i % 3 == 0:
new_b = (new_b[0] + (1.5 * triangle_width), new_y)
tri2 = [new_a, new_b, new_c]
transformblit(tri1, tri2, img, img)
x += triangle_width / 2
# x is rightmost point of next triangle
x = centre_point[0]
i = 0
new_a = a
new_b = b
new_c = c
# Fill to the left
print("Fill to the left")
while (x > 0):
i += 1
print(i, x, width)
if is_odd(i):
new_y = top_of_triangle
else:
new_y = bottom_of_triangle
if i % 3 == 1:
new_b = (new_b[0] - (1.5 * triangle_width), new_y)
elif i % 3 == 2:
new_a = (new_a[0] - (1.5 * triangle_width), new_y)
elif i % 3 == 0:
new_c = (new_c[0] - (1.5 * triangle_width), new_y)
tri2 = [new_a, new_b, new_c]
transformblit(tri1, tri2, img, img)
x -= triangle_width / 2
# Flip strip
strip = img.crop((0, top_of_triangle, width, bottom_of_triangle))
flip = ImageOps.flip(strip)
# Fill down
print("Fill down")
y = bottom_of_triangle
i = 0
while (y < height):
print(y, height)
i += 1
if is_odd(i):
img.paste(flip, (0, y))
else:
img.paste(strip, (0, y))
# img.show()
y += triangle_height
# Fill up
print("Fill up")
y = top_of_triangle
i = 0
while (y > 0):
print(y, 0)
i += 1
if is_odd(i):
img.paste(flip, (0, y - triangle_height))
else:
img.paste(strip, (0, y - triangle_height))
# img.show()
y -= triangle_height
img.show()
print("Saving to", outfile)
img.save(outfile, quality=100)
async def transform(event):
if not event.reply_to_msg_id:
await event.edit("`Reply to Any media..`")
return
reply_message = await event.get_reply_message()
if not reply_message.media:
await event.edit("`reply to a image/sticker`")
return
await event.edit("`Downloading Media..`")
if reply_message.photo:
transform = await bot.download_media(
reply_message,
"transform.png",
)
elif (DocumentAttributeFilename(file_name="AnimatedSticker.tgs")
in reply_message.media.document.attributes):
await bot.download_media(
reply_message,
"transform.tgs",
)
os.system("lottie_convert.py transform.tgs transform.png")
transform = "transform.png"
elif reply_message.video:
video = await bot.download_media(
reply_message,
"transform.mp4",
)
extractMetadata(createParser(video))
os.system(
"ffmpeg -i transform.mp4 -vframes 1 -an -s 480x360 -ss 1 transform.png"
)
transform = "transform.png"
else:
transform = await bot.download_media(
reply_message,
"transform.png",
)
try:
await event.edit("`Transforming this media..`")
cmd = event.pattern_match.group(1)
im = Image.open(transform).convert("RGB")
if cmd == "mirror":
IMG = ImageOps.mirror(im)
elif cmd == "flip":
IMG = ImageOps.flip(im)
elif cmd == "ghost":
IMG = ImageOps.invert(im)
elif cmd == "bw":
IMG = ImageOps.grayscale(im)
elif cmd == "poster":
IMG = ImageOps.posterize(im, 2)
IMG.save(Converted, quality=95)
await event.client.send_file(event.chat_id,
Converted,
reply_to=event.reply_to_msg_id)
await event.delete()
os.system("rm -rf *.mp4")
os.system("rm -rf *.tgs")
os.remove(transform)
os.remove(Converted)
except BaseException:
return
def Solve(self, problem):
answer = -1
# create and init dict for problems.
figures = problem.figures
if (problem.problemType == '2x2'):
#load training and answer images
imgA = Image.open(figures['A'].visualFilename)
imgB = Image.open(figures['B'].visualFilename)
imgC = Image.open(figures['C'].visualFilename)
img1 = Image.open(figures['1'].visualFilename)
img2 = Image.open(figures['2'].visualFilename)
img3 = Image.open(figures['3'].visualFilename)
img4 = Image.open(figures['4'].visualFilename)
img5 = Image.open(figures['5'].visualFilename)
img6 = Image.open(figures['6'].visualFilename)
# create pixel counts for training images using loadImages
pixelCountImgA = loadImages(imgA)
pixelCountImgB = loadImages(imgB)
pixelCountImgC = loadImages(imgC)
# create pixel counts for answer images using loadImages
Img1Pixels = loadImages(img1)
Img2Pixels = loadImages(img2)
Img3Pixels = loadImages(img3)
Img4Pixels = loadImages(img4)
Img5Pixels = loadImages(img5)
Img6Pixels = loadImages(img6)
#array of pixel counts for answer answer images
answerImagePixels = [
Img1Pixels, Img2Pixels, Img3Pixels, Img4Pixels, Img5Pixels,
Img6Pixels
]
# Cross coompare pixel count for training imagesself.
# This will find trivial matches where answer image pixels = training images pixels
if np.array_equal(pixelCountImgA,
pixelCountImgB): #if imgA, imgB are the same...
answerImage = pixelCountImgC #then answerImage var equals imgC pixels
for index, element in enumerate(
answerImagePixels
): #in which case we loop over answerImagePixels
if np.array_equal(
answerImage, element
): # if imgC pixels (via answerImage) equal answer image...
print('array_equal TRUE for imgA imgB')
answer = index + 1 #then answer var equals the corresponding answer image
break
#repeat the above for ImgA and imgC
elif np.array_equal(
pixelCountImgA,
pixelCountImgC): # otherwise, compare imgA and imgC
answerImage = pixelCountImgB # init answerImage to imgB
for index, element in enumerate(answerImagePixels):
if np.array_equal(answerImage, element):
print('array_equal TRUE for imgA imgC')
answer = index + 1
break
else:
#check for answer image as mirror or flip of training images.
# create var for mirroring; init to L-R mirror of imgA
mirrorpixelCountImgA = loadImages(ImageOps.mirror(imgA))
#same as above but for T-B flip
flippixelCountImgA = loadImages(ImageOps.flip(imgA))
if answer == -1 and similarity(mirrorpixelCountImgA,
pixelCountImgB)[1] > .95:
answer = similarityThrshld(
loadImages(ImageOps.mirror(imgC)), answerImagePixels)
print('answer = imgA, imgB mirrored')
if answer == -1 and similarity(mirrorpixelCountImgA,
pixelCountImgC)[1] > .95:
answer = similarityThrshld(
loadImages(ImageOps.mirror(imgB)), answerImagePixels)
print('answer = imgA, imgC mirrored')
if answer == -1 and similarity(flippixelCountImgA,
pixelCountImgB)[1] > .98:
answer = similarityThrshld(loadImages(ImageOps.flip(imgC)),
answerImagePixels)
print('answer = imgA, imgB flip')
if answer == -1 and similarity(flippixelCountImgA,
pixelCountImgC)[1] > .98:
answer = similarityThrshld(loadImages(ImageOps.flip(imgB)),
answerImagePixels)
print('answer = imgA, imgC flip')
# use array_equal to compare pixel count for ImgA and ImgB to ImgC and ImgA and ImgC to ImgB
for index, element in enumerate(answerImagePixels):
print('\n Now comparing answer: ' + str(answer) + ' to ' +
problem.name + ':\n')
#print('\n Similarity threshold for: ' + str(similarityThrshld()))
break
pass
return answer
elif FLAGS.camera:
while True:
key = input('商品をスキャンします。「Enter」を押して下さい')
if key == 'q':
break
photo_filename = '/tmp/data.jpg'
with picamera.PiCamera() as camera:
camera.resolution = (300, 400)
camera.start_preview()
camera.capture(photo_filename)
#try:
image = Image.open(photo_filename)
image = ImageOps.flip(image)
image = ImageOps.mirror(image)
#except:
#print('読込みエラー、再度入力お願いします。')
#else:
output_dir = 'output/'
time = datetime.now().strftime('%Y%m%d%H%M%S')
pred, score, r_image = yolo.detect_image(image)
image_path = output_dir + 'result_{}.jpg'.format(time)
r_image.save(image_path)
predict.show_image(image_path)
print(height) Lbox = (0, 0, 426, 720) Lframe1 = image.crop(Lbox) #Lframe1.show() #Cbox = (426,0,753.34,720) #Cframe = image.crop(Cbox) #Cframe.show() Rbox = (852, 0, 1280, 720) Rframe1 = image.crop(Rbox) #Rframe1.show() #run the HOG meth on Lbox&&Rbox #send out the frame back out modified & pplboxed #ScannedL & Cframe & ScannedR; merge the 3 together #might have to be a new image SL = ImageOps.flip(Lframe1) SR = ImageOps.flip(Rframe1) image.paste(SL, Lbox) image.paste(SR, Rbox) image.show() #pedest time stamps #5.29 ----- 6.04 #9.19 ----- 9.39 #lane #0.45 ----- 1.15
def voltearImagen(imagen):
voltear = ImageOps.flip(imagen)
return voltear
draw.text((0, 32-8), "=" + config.LOCAL_CURRENCY_CHAR, fill='white', font=currencyFont)
draw.text((12, 32-6), "{:,.2f} @ S{:,.9f}".format((lerp(previousBalance, currentBalance, timeDelta) * lerp(previousRate, currentRate, timeDelta)) * localExchange, lerp(previousRate, currentRate, timeDelta) * localExchange), fill='white', font=titleFont)
if screenToShow == 2:
canvas = Image.new(imageEncoding, (frameSize))
draw = ImageDraw.Draw(canvas)
draw.text((0, -1), "SafeMoon Price (USDT)", fill='white', font=titleFont)
draw.text((1, 10), "$", fill='white', font=safemoonFont_large)
draw.text((17, 7), "{:,.9f}".format(lerp(previousRate, currentRate, timeDelta)), fill="white", font=balanceFont)
sign = currentRate - previousRate
if sign > 0:
arrow2 = ImageOps.flip(arrow)
canvas.paste(arrow2, (105, 12))
if sign < 0:
canvas.paste(arrow, (105, 12))
perc24 = lerp(previousPerc, currentPerc, timeDelta)
includeSign = ""
if perc24 > 0:
includeSign = "+"
draw.text((2, 32-6), "24h {}{:,.2f}%".format(includeSign, perc24), fill='white', font=titleFont)
timeDelta = inverse_lerp(0, displayTime, time.time() - startTime)
if config.RUN_EMULATOR:
def gen_data(self, random_index):
img_pil = Image.open(
os.path.join(r'D:\datasets\LSLOGO\Logo-2K+',
self.pathlist[random_index])).convert('L')
pad_top = int(abs(np.random.uniform(0, self.pad_param)))
pad_bottom = int(abs(np.random.uniform(0, self.pad_param)))
pad_left = int(abs(np.random.uniform(0, self.pad_param)))
pad_right = int(abs(np.random.uniform(0, self.pad_param)))
rotate_param = np.random.uniform(0, self.rotate_degree_param)
flip_flag = np.random.randint(0, 1)
mirror_flag = np.random.randint(0, 1)
if (flip_flag):
img_pil = ImageOps.flip(img_pil)
if (mirror_flag):
img_pil = ImageOps.mirror(img_pil)
blur_rad = np.random.normal(loc=0.0, scale=1, size=None)
img_pil = img_pil.filter(ImageFilter.GaussianBlur(blur_rad))
enhancer_contrat = ImageEnhance.Contrast(img_pil)
enhancer_brightness = ImageEnhance.Brightness(img_pil)
enhancer_color = ImageEnhance.Color(img_pil)
contrast_factor = np.random.normal(loc=1.0, scale=0.25, size=None)
color_factor = np.max(
[0, 1 - abs(np.random.normal(loc=0, scale=0.5, size=None))])
translate_factor_hor = np.random.normal(loc=0, scale=5, size=None)
translate_factor_ver = np.random.normal(loc=0, scale=5, size=None)
brightness_factor = np.random.normal(loc=1.0, scale=0.5, size=None)
img_pil = enhancer_contrat.enhance(contrast_factor)
img_pil = enhancer_brightness.enhance(brightness_factor)
img_pil = enhancer_color.enhance(color_factor)
img_pil = ImageChops.offset(img_pil, int(translate_factor_hor),
int(translate_factor_ver))
img_pil = img_pil.rotate(rotate_param,
resample=Image.BILINEAR,
expand=True,
fillcolor=(255))
img = np.asarray(img_pil)
img = cv2.copyMakeBorder(img,
pad_top,
pad_bottom,
pad_left,
pad_right,
cv2.BORDER_CONSTANT,
value=(255, 255, 255))
img = cv2.resize(img, dsize=(self.input_shape))
img = img / 127.5 - 1
classT = self.pathlist[random_index]
classT = classT.split('/')[1]
targetT = self.classdf[self.classdf['class'] == classT]
targetI = targetT['index'].values[0]
target = np.zeros(self.numclass)
target[targetI] = 1
return img, target
async def imirror(event): # sourcery no-metrics
"imgae refelection fun."
reply = await event.get_reply_message()
mediatype = media_type(reply)
if not reply or not mediatype or mediatype not in ["Photo", "Sticker"]:
return await edit_delete(
event, "__Reply to photo or sticker to make mirror.__")
catevent = await event.edit("__Reflecting the image....__")
args = event.pattern_match.group(1)
if args:
filename = "catuserbot.webp"
f_format = "webp"
else:
filename = "catuserbot.jpg"
f_format = "jpeg"
try:
imag = await _cattools.media_to_pic(catevent, reply, noedits=True)
if imag[1] is None:
return await edit_delete(
imag[0],
"__Unable to extract image from the replied message.__")
image = Image.open(imag[1])
except Exception as e:
return await edit_delete(
catevent, f"**Error in identifying image:**\n__{str(e)}__")
flag = event.pattern_match.group(3) or "r"
w, h = image.size
if w % 2 != 0 and flag in ["r", "l"] or h % 2 != 0 and flag in ["u", "b"]:
image = image.resize((w + 1, h + 1))
h, w = image.size
if flag == "l":
left = 0
upper = 0
right = w // 2
lower = h
nw = right
nh = left
elif flag == "r":
left = w // 2
upper = 0
right = w
lower = h
nw = upper
nh = upper
elif flag == "u":
left = 0
upper = 0
right = w
lower = h // 2
nw = left
nh = lower
elif flag == "b":
left = 0
upper = h // 2
right = w
lower = h
nw = left
nh = left
temp = image.crop((left, upper, right, lower))
temp = ImageOps.mirror(temp) if flag in ["l", "r"] else ImageOps.flip(temp)
image.paste(temp, (nw, nh))
img = BytesIO()
img.name = filename
image.save(img, f_format)
img.seek(0)
await event.client.send_file(event.chat_id, img, reply_to=reply)
await catevent.delete()
else:
stage = stages.Stage1()
# 初期描画
root = tk.Tk()
root.title(stage.name)
root.geometry(f'{WINDOW_WIDTH}x{WINDOW_HEIGHT}+0+0')
cv = tk.Canvas(root, width=WINDOW_WIDTH, height=WINDOW_HEIGHT, bg='white')
cv.pack()
cv.focus_set()
# 画像の読み込み
# キャラクター
obake_img = Image.open('./img/obake.png')
obake_img = obake_img.resize((IMG_SIZE, IMG_SIZE))
obake_flip_img = ImageOps.flip(obake_img) # 上下反転
obake_mirror_img = ImageOps.mirror(obake_img) # 左右反転（右向き）
obake_fm_img = ImageOps.mirror(obake_flip_img) # 上下左右反転
obake_tkimg = ImageTk.PhotoImage(obake_img)
obake_flip_tkimg = ImageTk.PhotoImage(obake_flip_img)
obake_mirror_tkimg = ImageTk.PhotoImage(obake_mirror_img)
obake_fm_tkimg = ImageTk.PhotoImage(obake_fm_img)
# 重力ブロック
udarrow_img = Image.open('./img/updownarrow.png')
udarrow_img = udarrow_img.resize((BLOCK_SIZE, BLOCK_SIZE))
udarrow2_img = udarrow_img.resize((BLOCK_SIZE*2, BLOCK_SIZE*2))
udarrow_tkimg = ImageTk.PhotoImage(udarrow_img)
udarrow2_tkimg = ImageTk.PhotoImage(udarrow2_img)
# 看板
triple_size = (BLOCK_SIZE*3, BLOCK_SIZE*3)
dsc_J_img = Image.open(f'./img/dsc_J.png').resize(triple_size)
for chunk in r.iter_content(chunk_size=1024):
raw_bytes += chunk
a = raw_bytes.find(b'\xff\xd8\xff')
b = raw_bytes.find(b'\xff\xd9',a)
if a != -1 and b != -1:
jpg = raw_bytes[a:b+2]
raw_bytes = raw_bytes[b+2:]
imgIo=io.BytesIO(jpg)
img=Image.open(imgIo)
# cvImg=cv2.cvtColor(np.array(img.convert("RGB")),cv2.COLOR_RGB2BGR)
c+=1
c=c % 5
if(c==0):
processing.useImg(np.array(ImageOps.mirror(ImageOps.flip(img))),mc)
else:
print("INVALID CODE CAN'T PROCEED")
if (last_col - first_col + 1 > width) or (last_row - first_row + 1 >
height):
s -= 1
else:
im.crop((first_col - 1, first_row - 1, last_col + 2, last_row + 2))
return im
# Base image
text = "coil winder".upper()
im = fit_image(text, 300, 24)
im.save('label.png')
im = ImageOps.flip(im)
# Convert into a list of lists of numbers, where 0 is black and 255 is white.
im = im.convert(mode='1')
pixels = list(im.getdata())
width, height = im.size
pixels = [pixels[i * width:(i + 1) * width] for i in xrange(height)]
up_position = '105\n'
down_position = '90\n'
start_motor = '182\n'
stop_motor = '0\n'
# Send the pixel data as up and down commands.
ser = serial.Serial('/dev/ttyACM0')
sleep(1)
print ser.write(down_position)
print file, round(total_count2 * 100.0 / total_count, 2)
total_count2 += 1
row = fish_label(label)
lbl_text = str(row[0]) + "," + str(row[1]) + "," + str(
row[2]) + "," + str(row[3]) + "," + str(row[4]) + "," + str(
row[5]) + "," + str(row[6]) + "," + str(row[7])
name, ext = file.split(".")
for t in xrange(8):
img = Image.open(path + file, 'r')
# print t
if t == 1:
img = ImageOps.mirror(img)
if t == 2:
img = ImageOps.flip(img)
if t == 3:
img = ImageOps.mirror(img)
img = ImageOps.flip(img)
if t == 4:
img = img.rotate(90)
if t == 5:
img = img.rotate(90)
img = ImageOps.mirror(img)
if t == 6:
img = img.rotate(270)
if t == 7:
img = img.rotate(270)
img = ImageOps.mirror(img)
## making the size require aspec ratio
img_w, img_h = img.size
def execute(self, image, query):
return ImageOps.flip(image)
def export_images(data, path=".", only=None):
if not os.path.exists(path):
os.path.makedirs(path)
# export chr
outfile = "mm-chr.png"
print("exporting", outfile)
outfile = os.path.join(path, outfile)
chr_image = produce_chr_sheet(data)
chr_image.save(outfile)
# export title
outfile = "mm-title.png"
print("exporting", outfile)
outfile = os.path.join(path, outfile)
produce_title_screen(data, 0).save(outfile)
# export ending
outfile = "mm-ending.png"
print("exporting", outfile)
outfile = os.path.join(path, outfile)
produce_title_screen(data, 1).save(outfile)
# export levels
for level in data.levels:
for hard in [False, True]:
outfile = "mm-" + str(level.world_idx + 1) + "-" + str(
level.world_sublevel + 1) + ("h" if hard else "") + ".png"
print("exporting " + outfile + " ...")
outfile = os.path.join(path, outfile)
# create tiles per-palette per-level (could be optimized to per-world)
minitile_images = produce_micro_tile_images(
data, level.world, hard)
# create object data images
object_images = produce_object_images(data)
w = 256
h = 32 * constants.macro_rows_per_level
img = Image.new('RGB', (w, h), color='black')
draw = ImageDraw.Draw(img)
tile_rows, macro_tile_idxs = level.produce_med_tiles(hard)
y = h
dangerous_tiles = [[
False for y in range(constants.macro_rows_per_level * 4)
] for x in range(0x20)]
for row in tile_rows:
x = -16
y -= 16
for medtile_idx in row:
x += 16
offsets = [(0, 0), (8, 0), (0, 8), (8, 8)]
medtile = level.world.get_med_tile(medtile_idx)
palette_idx = level.world.get_med_tile_palette_idx(
medtile_idx, hard) % 4
if palette_idx is None:
continue
# draw subtiles
for i in range(4):
microtile_idx = level.world.get_micro_tile(
medtile[i], hard)
offx = offsets[i][0]
offy = offsets[i][1]
_x = x + offx
_y = y + offy
if (microtile_idx in constants.dangerous_micro_tiles):
dangerous_tiles[_x // 8][_y // 8] = True
else:
img.paste(
minitile_images[palette_idx][microtile_idx],
(_x, _y))
# objects
for obj in level.objects:
if obj.drop:
continue
x = obj.x * 8 - 4
y = obj.y * 8
text = hb(obj.gid)
objimg = object_images[
obj.gid] if obj.gid < len(object_images) else None
if obj.flipx and obj.flipy:
text += "+"
elif obj.flipx:
text += "-"
elif obj.flipy:
text += "|"
if objimg is None:
draw.text((x, y),
text,
fill="white" if
self.data.get_object_name(obj.gid)[0:4] != "unk-"
else "red")
else:
x += 4 - objimg.width // 2 + objimg._mm_offset[0]
y += 8 - objimg.height + objimg._mm_offset[1]
if not objimg._mm_hard or dangerous_tiles[obj.x][obj.y]:
paste_image = objimg
if obj.flipx:
paste_image = ImageOps.mirror(paste_image)
if obj.flipy:
paste_image = ImageOps.flip(paste_image)
img.paste(paste_image, (x, y))
img.save(outfile)
def flipImage(arch):
img = ImageOps.flip(arch)
return img
def label_objects(win, occluders, sposs, isFamiliar, isVertical, side, label_snd, tracker=None):
hand_img = hand_img_obj
hand = visual.ImageStim(win)
for i in range(2):
occluders[i].setPos(sposs[i])
# randomise or select positions:
sposLabeled = sposs[side] if side != None else None
occluderLabeled = occluders[side] if side != None else None
sndLabel = sound.Sound(value=label_snd)
sndLabel.setVolume(0.8)
if isVertical: # in vertical positioning of occluders
handX = random.choice([-c.OCC_SIZE, c.OCC_SIZE])
handY = sposLabeled[1]
angle = 0
if handX > 0:
hand_img = ImageOps.flip(hand_img)
angle = 180
else:
handX, handY, angle = calculations.calculate_handPos(sposLabeled)
if sposLabeled[0] < 0:
hand_img = ImageOps.flip(hand_img)
# calculate handshake steps
shakeX, shakeY = calculations.calculate_handShake(angle)
# rotate hand image with angle
hand_img = hand_img.rotate(angle, expand=True)
hand = visual.ImageStim(win, hand_img)
occluderLabeled.lineColor = "red"
occluderLabeled.lineWidth = 3
event.clearEvents()
if tracker:
tracker.log("Labeling_{0}_STARTS".format("fam_object" if isFamiliar else "test_object"))
frames = 420 if isFamiliar else 480
for frameN in range(frames):
occluders[0].draw()
occluders[1].draw()
# play labeling voice
if frameN == 75:
pass
sndLabel.play()
# pointing hand
if frameN > 50:
m = frameN%50
if m < 25:
hand.setPos((handX + shakeX*m, handY + shakeY*m))
hand.draw()
else:
hand.setPos((handX + shakeX*(50-m), handY + shakeY*(50-m)))
hand.draw()
win.flip()
_getKeypress(win, tracker=tracker)
def test_sanity(self):
ImageOps.autocontrast(hopper("L"))
ImageOps.autocontrast(hopper("RGB"))
ImageOps.autocontrast(hopper("L"), cutoff=10)
ImageOps.autocontrast(hopper("L"), ignore=[0, 255])
ImageOps.autocontrast_preserve(hopper("L"))
ImageOps.autocontrast_preserve(hopper("RGB"))
ImageOps.autocontrast_preserve(hopper("L"), cutoff=10)
ImageOps.autocontrast_preserve(hopper("L"), ignore=[0, 255])
ImageOps.colorize(hopper("L"), (0, 0, 0), (255, 255, 255))
ImageOps.colorize(hopper("L"), "black", "white")
ImageOps.crop(hopper("L"), 1)
ImageOps.crop(hopper("RGB"), 1)
ImageOps.deform(hopper("L"), self.deformer)
ImageOps.deform(hopper("RGB"), self.deformer)
ImageOps.equalize(hopper("L"))
ImageOps.equalize(hopper("RGB"))
ImageOps.expand(hopper("L"), 1)
ImageOps.expand(hopper("RGB"), 1)
ImageOps.expand(hopper("L"), 2, "blue")
ImageOps.expand(hopper("RGB"), 2, "blue")
ImageOps.fit(hopper("L"), (128, 128))
ImageOps.fit(hopper("RGB"), (128, 128))
ImageOps.flip(hopper("L"))
ImageOps.flip(hopper("RGB"))
ImageOps.grayscale(hopper("L"))
ImageOps.grayscale(hopper("RGB"))
ImageOps.invert(hopper("L"))
ImageOps.invert(hopper("RGB"))
ImageOps.mirror(hopper("L"))
ImageOps.mirror(hopper("RGB"))
ImageOps.posterize(hopper("L"), 4)
ImageOps.posterize(hopper("RGB"), 4)
ImageOps.solarize(hopper("L"))
ImageOps.solarize(hopper("RGB"))
