def render_image_background(self, image_path, opacity=True):
image = Image(image_path)
if type(opacity) is int:
image.opacity(opacity)
elif opacity is True:
image.opacity(50)
return image
def test_fromblob(self):
with open('../example/X.jpg', 'rb') as f:
data = f.read()
b = Blob(data)
img = Image(b)
img.write('X2.jpg')
self.assertEqual(type(img), Image)
def pgmagick_image(source, **options):
"""
Try to open the source file using pgmagick, ignoring any errors.
"""
# Use a StringIO wrapper because if the source is an incomplete file like
# object, PIL may have problems with it. For example, some image types
# require tell and seek methods that are not present on all storage
# File objects.
# import ipdb; ipdb.set_trace()
if not source:
return
source.open() # If tried by a previous source_generator, will be closed
source = StringIO(source.read())
try:
blob = Blob(source.read())
image = Image(blob)
except Exception:
logger.exception("unable to read image to create thumbnail")
return
if not image.isValid():
return
return convertGMtoPIL(image)
def test_scale_jpeg(self):
img = api.Image((400, 400), 'blue')
img.write(self.tmp_filename_jpg)
img2 = Image(Blob(open(self.tmp_filename_jpg).read()),
Geometry(200, 200))
img2.scale('200x200')
img2.write(self.tmp_filename_jpg)
def _watermark(self, image, watermark_path, opacity, size, position_str):
with open(watermark_path, "rb") as watermark_file:
watermark = self.get_image(watermark_file)
image_size = self.get_image_size(image)
layer = Image(Geometry(image_size[0], image_size[1]), "transparent")
if opacity < 1:
self._reduce_opacity(watermark, opacity)
if not size:
mark_size = self.get_image_size(watermark)
else:
mark_size = tuple(
self._get_new_watermark_size(size, self.get_image_size(watermark))
)
options = {
"crop": "center",
"upscale": mark_size > self.get_image_size(watermark),
}
watermark = self.scale(watermark, mark_size, options)
watermark = self.crop(watermark, mark_size, options)
if position_str == "tile":
for x_pos in range(0, image_size[0], mark_size[0]):
for y_pos in range(0, image_size[1], mark_size[1]):
layer.composite(watermark, x_pos, y_pos, CoOp.OverCompositeOp)
else:
position = self._define_watermark_position(
position_str, image_size, mark_size
)
layer.composite(watermark, position[0], position[1], CoOp.OverCompositeOp)
image.composite(layer, 0, 0, CoOp.OverCompositeOp)
return image
def pgmagick_image(source, **options):
"""
Try to open the source file using pgmagick, ignoring any errors.
"""
# Use a StringIO wrapper because if the source is an incomplete file like
# object, PIL may have problems with it. For example, some image types
# require tell and seek methods that are not present on all storage
# File objects.
# import ipdb; ipdb.set_trace()
if not source:
return
source.open() # If tried by a previous source_generator, will be closed
source = StringIO(source.read())
try:
blob = Blob(source.read())
image = Image(blob)
except Exception:
logger.exception("unable to read image to create thumbnail")
return
if not image.isValid():
return
return convertGMtoPIL(image)
def ConvertJp2(input):
"""
If the input is a jp2 picture, the image is transformed into bmp,
else the image is returned without any modifications.
@param input: A binary string representing the picture to convert
@type input: A string
@return: A binary string representing the picture in bmp, or the original input if the input is not a jp2 stream.
"""
jp2 = open("tmp.jp2", "wb")
jp2.write(input)
jp2.close()
if isMagick == False:
geojasper = "geojasper"
if (sys.platform != "win32") and os.path.isfile(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "geojasper", geojasper)
):
geojasper = os.path.join(os.path.dirname(os.path.realpath(__file__)), "..", "geojasper", geojasper)
a = os.popen(geojasper + " -f tmp.jp2 -F tmp.jpg")
a.close()
else:
jpg = MImage("tmp.jp2")
jpg.write("tmp.jpg")
try:
f = open("tmp.jpg", "rb")
input = f.read()
f.close()
except IOError, msg:
pass
def test_fromblob(self):
with open('../example/X.jpg', 'rb') as f:
data = f.read()
b = Blob(data)
img = Image(b)
img.write('X2.jpg')
self.assertEqual(type(img), Image)
def get_image( self ):
# Open the image
try:
img_file = urllib.urlopen( self.path )
img_data = img_file.read()
bytes_read = len(img_data)
except urllib.HTTPError as e:
raise ImageRetrievalError(self.path, "Error code: %s" % e.code)
except urllib.URLError as e:
raise ImageRetrievalError(self.path, e.reason)
blob = Blob( img_data )
image = Image( blob )
# Check if the whole image should be used and cropped if necessary.
src_width = image.size().width()
src_height = image.size().height()
if self.width != src_width or self.height != src_height:
box = Geometry( self.width, self.height, self.x_min_src, self.y_min_src )
image.crop( box )
# Estimates the size in Bytes of this image part by scaling the number
# of Bytes read with the ratio between the needed part of the image and
# its actual size.
self.estimated_size = bytes_read * abs(float(self.width * self.height) /
float(src_width * src_height))
return image
def test_image_setpixels(self):
img = Image(Geometry(300, 200), Color('transparent'))
pixels = img.setPixels(40, 50, 5, 5)
for pixel in pixels:
pixel.red = 50
img.syncPixels()
for pixel in img.getPixels(40, 50, 5, 5):
self.assertEqual(50, pixel.red)
def get_sized_image(filename, size):
if not os.path.exists(DIR):
os.mkdir(DIR)
cache_hash = sha1('{0}\0{1}'.format(filename, size)).hexdigest() + '.jpg'
cache_path = os.path.join(DIR, cache_hash)
if not os.path.exists(cache_path):
im = Image(filename.encode('utf-8'))
im.sample(size)
im.write(cache_path)
return '/'.join(PARTS + (cache_hash,))
def resize2( srcFile="", destFile="", w=200,h=200 ):
blobData = Blob(open(srcFile).read())
if ( h != -1 ):
img = Image( blobData, Geometry(w, h))
img.scale("%dx%d!" % (w,h))
else:
img = Image( blobData )
img.scale("%dx!" % w )
img.profile("*",Blob())
img.write(destFile)
return "True"
def resize0(srcFile="", destFile="", w=200):
img = Image(srcFile)
sw = img.columns()
sh = img.rows()
if (sw > w):
tw = w
th = sh * (float(w) / float(sw))
img.scale("%dx%d" % (tw, th))
img.profile("*", Blob())
img.write(destFile)
return "True"
def get_image( self ):
# Open the image
img_file = urllib.urlopen( self.path )
blob = Blob( img_file.read() )
image = Image( blob )
# Check if the whole image should be used and croped
# if necessary.
src_width = image.size().width()
src_height = image.size().height()
if self.width != src_width or self.height != src_height:
box = Geometry( self.width, self.height, self.x_min_src, self.y_min_src )
image.crop( box )
return image
def process_images(subdir):
curr_dir = data_dir + subdir + '/'
counter = 1
files = os.listdir(curr_dir)
interval = int(len(files) / target)
for file in files:
if counter % interval == 0 and counter / interval <= target:
img = Image(curr_dir + '/' + file)
img.type(ImageType.GrayscaleType)
img.write(out_dir + subdir + str(counter / interval) + '.tif')
counter = counter + 1
def resize10(srcFile="", destFile="", w=200):
img = Image(srcFile)
sw = img.columns()
sh = img.rows()
scale = sw * sh
if (scale > w):
tw = int(sw * ((float(w) / float(scale))**0.5))
th = int(w / tw)
img.scale("%dx%d" % (tw, th))
img.profile("*", Blob())
img.write(destFile)
return "True"
def test_color_histogram(self):
redColor = Color('red')
im = Image(Geometry(30, 20), redColor)
histogram = im.colorHistogram()
self.assertEqual(1, len(histogram))
# test in, __getitem__
self.assertIn(redColor, histogram)
self.assertEqual(30 * 20, histogram[redColor])
# iteration example
for packet in histogram:
color, count = packet.key(), packet.data()
self.assertEqual(redColor, color)
self.assertEqual(30 * 20, count)
def test_color_histogram(self):
redColor = Color('red')
im = Image(Geometry(30, 20), redColor)
histogram = im.colorHistogram()
self.assertEqual(1, len(histogram))
# test in, __getitem__
self.assertIn(redColor, histogram)
self.assertEqual(30 * 20, histogram[redColor])
# iteration example
for packet in histogram:
color, count = packet.key(), packet.data()
self.assertEqual(redColor, color)
self.assertEqual(30 * 20, count)
def image_process():
# If you change directory of loaded images, change this variable
# it will change the directory for the rest of this function.
# the '/' is important at the end of the file name.
load_images_here = 'load_images_here/'
files = [
f for f in listdir(load_images_here)
if isfile(join(load_images_here + '.', f))
]
# files.remove('program.py')
# files.remove('README.md')
print(files)
num = 0
i = 0
image_scale = input("Scale in px. Ex: 1000x1000 \n")
for file in files:
new_filename = file
no_spaces_true = True
if ' ' in file:
no_spaces_true = False
print("Found spaces...")
file_no_space = file.replace(' ', '_')
new_filename = file_no_space
print("replaced spaces....")
print("writing..." + file + ' -> ' + file_no_space)
file = load_images_here + file
file_no_space = load_images_here + file_no_space
shutil.copy(file, file_no_space)
print("New File is written.")
file = file_no_space
print(file)
if no_spaces_true == True:
im = Image(load_images_here + file)
else:
im = Image(file)
im.quality(100)
im.scale(image_scale)
# im.sharpen(1.0) # This doesn't seem to help. Keeping it for further research
im.write('pre_processed/sc' + str(num) + '_' +
new_filename) # 'sc' in this line indicates 'scaled'
if no_spaces_true == False:
clean_up = "rm " + file_no_space
os.system(clean_up)
num += 1
i += 1
def convertToJpg():
problemImages = []
os.chdir("data/FullPages")
batchLevel = os.listdir(os.getcwd())
totalBatches = len(batchLevel)
currentBatch = 0
for i in batchLevel:
currentBatch += 1
os.chdir(i)
issueLevel = os.listdir(os.getcwd())
totalIssues = len(issueLevel)
currentIssue = 0
for j in issueLevel:
currentIssue += 1
os.chdir(j)
jp2Images = os.listdir(os.getcwd())
totalImages = len(jp2Images)
currentImage = 0
for k in jp2Images:
currentImage += 1
try:
im = Image(str(k))
newName = k[:-3] + 'jpg'
im.write(str(newName))
#Status update on how many images have been processed
sys.stdout.write("\rConverted Batch: " +
str(currentBatch) + "/" +
str(totalBatches) + " Issue: " +
str(currentIssue) + "/" +
str(totalIssues) + " Image: " +
str(currentImage) + "/" +
str(totalImages) + " ")
sys.stdout.flush()
#remove old jp2 image to conserve space, also only remove if conversion was successful
os.remove(k)
except:
problemImages.append(str(k))
os.chdir('..')
os.chdir('..')
os.chdir('../..')
#end of process message
if len(problemImages) > 0:
print(
"These are images that could not be converted to jpg for some reason. Please check for corruption/ proper download."
)
print(problemImages)
else:
print("All images converted successfully")
def _xor_composite_clip_layer(self, clips, layer_level=0):
"""
round two clipping.
"""
#skip the first clip as it doesn't need anything taken away from it.
this_clip = GMImage(
os.path.join(self.clips_dir, 'clip-%s.png' % clips[0]))
this_clip.write(
os.path.join(self.clips_dir, "clip-co-%s.png" % clips[0]))
#self.masks.append(os.path.join(self.clips_dir, 'clip-co-%s.png' %
#clips[0]))
clip_i = 0
for clip_id in clips[1:]:
previous_clip = GMImage(
os.path.join(self.clips_dir, 'clip-%s.png' % clips[clip_i]))
this_clip = GMImage(
os.path.join(self.clips_dir, 'clip-%s.png' % clip_id))
this_clip.composite(previous_clip, 0, 0, co.XorCompositeOp)
img_file = os.path.join(self.clips_dir, "clip-co-%s.png" % clip_id)
this_clip.write(img_file)
clip_i = clip_i + 1
im = Image.open(img_file)
if not im.getbbox(): # nothing there so delete it
os.unlink(img_file)
def _xor_composite_clip_layer(self, clips, layer_level=0):
"""
round two clipping.
"""
#skip the first clip as it doesn't need anything taken away from it.
this_clip = GMImage(os.path.join(self.clips_dir, 'clip-%s.png' %
clips[0]))
this_clip.write(os.path.join(self.clips_dir, "clip-co-%s.png" %
clips[0]))
#self.masks.append(os.path.join(self.clips_dir, 'clip-co-%s.png' %
#clips[0]))
clip_i = 0
for clip_id in clips[1:]:
previous_clip = GMImage(os.path.join(self.clips_dir, 'clip-%s.png' %
clips[clip_i]))
this_clip = GMImage(os.path.join(self.clips_dir, 'clip-%s.png' %
clip_id))
this_clip.composite(previous_clip, 0, 0, co.XorCompositeOp)
img_file = os.path.join(self.clips_dir, "clip-co-%s.png" % clip_id)
this_clip.write(img_file)
clip_i = clip_i + 1
im = Image.open(img_file)
if not im.getbbox(): # nothing there so delete it
os.unlink(img_file)
def create_thumb(pvi_img_path):
img = Image(Blob(open(pvi_img_path).read()))
img.scale(ws.thumb_size_x + 'x' + ws.thumb_size_y)
img.quality(ws.thumb_jpeg_compression_quality)
img.write(ws.working_directory + "tmp_thumb_resized.jpg")
blob = Blob(open(ws.working_directory + "tmp_thumb_resized.jpg").read())
return blob.data
def test_image_resize(self):
im = Image(Geometry(300, 200), Color('transparent'))
g = Geometry(150, 100)
ft = FilterTypes.BlackmanFilter
blur = 0.5
im.resize(g, ft, blur)
im.resize(g, ft)
im.resize(g)
def resize0( srcFile="", destFile="", w=200 ):
img = Image(srcFile)
sw = img.columns()
sh = img.rows()
if ( sw > w ):
tw = w
th = sh*(float(w)/float(sw))
img.scale("%dx%d"%(tw,th))
img.profile("*", Blob())
img.write(destFile)
return "True"
def convertirJPEG2000(self,nombre_imagen,nuevo_nombre,optimizado=True,calidad=100): #tiempo_inicio=int(time.time()) tiempo_inicio=time.time() print "convert" resultado=False try: imagen = Image_PG(RUTA_IMAGENES+nombre_imagen) imagen.write(RUTA_IMAGENES+nuevo_nombre) resultado=True except Exception as e: print "Error...." print e #tiempo_fin=int(time.time()) tiempo_fin=time.time() self.__tiempo=tiempo_fin-tiempo_inicio return resultado
def buildImage(self):
#first build the image, we need to know how big it is
with open(self.dataBase + "base.json", "r") as f:
base = json.loads(f.read())
self.totalWidth = base['width']
self.totalHeight = base['height']
print ("Creating large base image", int(self.totalWidth), 'x',int(self.totalHeight) )
im = Image(Geometry(int(self.totalWidth), int(self.totalHeight)), Color("black"))
#throw a logo onnn
#layer = Image('logo.png')
#im.composite(layer, 0, 0, co.OverCompositeOp)
for file in os.listdir(self.dataNodes):
if file.endswith('.json'):
with open(self.dataNodes + file, "r") as f:
nodes = json.loads(f.read())
print ("Building Image Nodes", self.dataNodes + file, len(nodes))
self.buildCounterNodeTotal = len(nodes)
self.buildCounterNode = 0
for node in nodes:
self.buildCounterNode+=1
print (self.buildCounterNode / self.buildCounterNodeTotal * 100)," percent complete of this batch \r",
layer = Image(self.dataCircles + str(node['id']) +'.png')
cords = self.convertCoordinates(node['posX'],node['posY'])
im.composite(layer, int(cords[0]), int(cords[1]), co.OverCompositeOp)
print ("")
print ("Writing large file out")
im.write('base.png')
def resize10( srcFile="", destFile="", w=200 ):
img = Image( srcFile )
sw = img.columns()
sh = img.rows()
scale = sw*sh
if ( scale > w ):
tw = int(sw*((float(w)/float(scale))**0.5))
th = int(w/tw)
img.scale("%dx%d"%(tw,th))
img.profile("*",Blob())
img.write(destFile)
return "True"
def thumbnail(request, type, identifier):
response = HttpResponse(mimetype="image/png")
size = str(request.GET.get("size", "190x270"))
if not re.match("\d+[x]\d+", size):
size = "190x270"
cache_key = "thumbnail:%s:%s:%s" % (type, identifier, size)
cached = cache.get(cache_key)
if cached is None:
if type == "file":
file_ = str(os.path.join(settings.INCOMING_DIRECTORY, identifier))
elif type == "document":
document = get_object_or_404(Document, pk=identifier)
file_ = Blob(document.document.read())
image = Image(file_)
image.filterType(FilterTypes.SincFilter)
image.scale(size)
output = Blob()
image.write(output, "png")
response.write(output.data)
cache.set(cache_key, output.data)
else:
response.write(cached)
return response
def dummy_image(self, width, height):
im = Image(Geometry(width, height), Color(240, 240, 240))
im.strokeColor(Color(128, 128, 128))
im.strokeWidth(1)
im.draw(DrawableLine(0, 0, width, height))
im.draw(DrawableLine(0, height, width, 0))
return im
def resize3( srcFile="", destFile="", w=200,h=200, color="", crop=False, align="center" ):
img = Image(srcFile)
img.scale("%dx%d>"%(w,h))
img.profile("*",Blob())
img.write(destFile)
return "True"
def _in_composite(self, previous_clips, clips):
for prev_clip_id in previous_clips:
for this_clip_id in clips:
previous_clip = GMImage(os.path.join(self.clips_dir, 'clip-co-%s.png' %
prev_clip_id))
this_clip = GMImage(os.path.join(self.clips_dir, 'clip-co-%s.png' %
this_clip_id))
this_clip.composite(previous_clip, 0, 0, co.InCompositeOp)
img_file = os.path.join(self.clips_dir, "clip-in-%s-%s.png" %
(prev_clip_id, this_clip_id))
this_clip.write(img_file)
im = Image.open(img_file)
if not im.getbbox(): # nothing there so delete it
os.unlink(img_file)
else:
self.masks.append(img_file)
def _composite(self, mask, pic, i=0):
"""
composite of mask and pic. also trims it and renames with offset.
"""
base = GMImage(pic)
layer = GMImage(mask)
base.composite(layer, 0, 0, co.CopyOpacityCompositeOp)
finished_clip_filename = os.path.join(self.target_directory, self.junk_dir, "%s-%s.png" %
(os.path.basename(pic), os.path.basename(mask)))
base.write(finished_clip_filename)
box = self._trim(finished_clip_filename,
os.path.join(self.target_directory, self.raster_dir, "%i.png" % i))
self._potrace(mask, i=i,
trimmedpng=os.path.join(self.target_directory, self.raster_dir,"%i.png" % i))
self.pieces[i] = box
def check_img():
'''
Checar se o arquivo declarado é realmente uma imagem;
em caso afirmativo, carrega o arquivo
'''
try:
check = Image()
check.ping(sys.argv[1])
except RuntimeError:
print sys.argv[1], "is not a valid image file!"
sys.exit()
except:
print "unexpected error:", sys.exc_info()[0]
raise
sys.exit()
else:
return sys.argv[1]
def check_img():
'''
Checar se o arquivo declarado é realmente uma imagem;
em caso afirmativo, carrega o arquivo
'''
try:
check = Image()
check.ping(sys.argv[1])
except RuntimeError:
print sys.argv[1], "is not a valid image file!"
sys.exit()
except:
print "unexpected error:", sys.exc_info()[0]
raise
sys.exit()
else:
return sys.argv[1]
def get_image( self ):
# Open the image
try:
img_file = urllib.urlopen( self.path )
except urllib.HTTPError as e:
raise ImageRetrievalError(self.path, "Error code: %s" % e.code)
except urllib.URLError as e:
raise ImageRetrievalError(self.path, e.reason)
blob = Blob( img_file.read() )
image = Image( blob )
# Check if the whole image should be used and cropped if necessary.
src_width = image.size().width()
src_height = image.size().height()
if self.width != src_width or self.height != src_height:
box = Geometry( self.width, self.height, self.x_min_src, self.y_min_src )
image.crop( box )
return image
def test_image_resize(self):
im = Image(Geometry(300, 200), Color('transparent'))
g = Geometry(150, 100)
ft = FilterTypes.BlackmanFilter
blur = 0.5
im.resize(g, ft, blur)
im.resize(g, ft)
im.resize(g)
def _watermark(self, image, watermark_path, opacity, size, position_str):
watermark = self.get_image(open(watermark_path))
image_size = self.get_image_size(image)
layer = Image(Geometry(image_size[0], image_size[1]), 'transparent')
if opacity < 1:
self._reduce_opacity(watermark, opacity)
if not size:
mark_size = self.get_image_size(watermark)
else:
mark_size = self._get_new_watermark_size(size, self.get_image_size(watermark))
options = {'crop': 'center',
'upscale': False}
watermark = self.scale(watermark, mark_size, options)
watermark = self.crop(watermark, mark_size, options)
position = self._define_watermark_position(position_str, image_size, mark_size)
layer.composite(watermark, position[0], position[1], CoOp.OverCompositeOp)
image.composite(layer, 0, 0, CoOp.OverCompositeOp)
return image
def resize3(srcFile="",
destFile="",
w=200,
h=200,
color="",
crop=False,
align="center"):
img = Image(srcFile)
img.scale("%dx%d>" % (w, h))
img.profile("*", Blob())
img.write(destFile)
return "True"
def watercolor(self,imgObj):
print "watercolor()"
img=imgObj
#img.blur(2,2)
img.oilPaint(1)
img.enhance()
img.sharpen()
pink=Color(250,218,221,75)
toplayer=Image(img.size(),pink)
toplayer.matte(True)
img.matte(True)
img.composite(toplayer,0,0,CompositeOperator.CopyOpacityCompositeOp)
img.blur(0,1)
img.write('output.png')
return img
def evaluar(self, url_imagen):
resultado = True
self.__nueva_url = url_imagen
try:
nombre, extension = os.path.splitext(url_imagen)
if (extension in self.__extensiones):
self.__nueva_url = nombre + str(int(time.time())) + ".jpeg"
imagen = Image_PG(RUTA_IMAGENES + url_imagen)
imagen.write(RUTA_IMAGENES + self.__nueva_url)
imagen = Image.open(RUTA_IMAGENES + self.__nueva_url)
imagen = self.escalaGrises(imagen)
self.__nueva_url = "grises" + self.__nueva_url
imagen.save(RUTA_IMAGENES + self.__nueva_url,
optimize=True,
quality=100)
except Exception as e:
print "Error EvaluarImagen.evaluar..."
print e
resultado = False
return resultado
def get_im(content):
if hasattr(content, 'read'):
content = content.read()
if not content:
return
else:
try:
f = Blob(content)
return Image(f)
except:
return
def _in_composite(self, previous_clips, clips):
for prev_clip_id in previous_clips:
for this_clip_id in clips:
previous_clip = GMImage(
os.path.join(self.clips_dir,
'clip-co-%s.png' % prev_clip_id))
this_clip = GMImage(
os.path.join(self.clips_dir,
'clip-co-%s.png' % this_clip_id))
this_clip.composite(previous_clip, 0, 0, co.InCompositeOp)
img_file = os.path.join(
self.clips_dir,
"clip-in-%s-%s.png" % (prev_clip_id, this_clip_id))
this_clip.write(img_file)
im = Image.open(img_file)
if not im.getbbox(): # nothing there so delete it
os.unlink(img_file)
else:
self.masks.append(img_file)
def _watermark(self, image, watermark_path, opacity, size, position_str):
watermark = self.get_image(open(watermark_path))
image_size = self.get_image_size(image)
layer = Image(Geometry(image_size[0], image_size[1]), 'transparent')
if opacity < 1:
self._reduce_opacity(watermark, opacity)
if not size:
mark_size = self.get_image_size(watermark)
else:
mark_size = self._get_new_watermark_size(
size, self.get_image_size(watermark))
options = {'crop': 'center', 'upscale': False}
watermark = self.scale(watermark, mark_size, options)
watermark = self.crop(watermark, mark_size, options)
position = self._define_watermark_position(position_str, image_size,
mark_size)
layer.composite(watermark, position[0], position[1],
CoOp.OverCompositeOp)
image.composite(layer, 0, 0, CoOp.OverCompositeOp)
return image
def get_image(self):
# Open the image
try:
r = requests.get(self.path,
allow_redirects=True,
verify=verify_ssl)
if not r:
raise ValueError("Could not get " + self.path)
if r.status_code != 200:
raise ValueError("Unexpected status code ({}) for {}".format(
r.status_code, self.path))
img_data = r.content
bytes_read = len(img_data)
except requests.exceptions.RequestException as e:
raise ImageRetrievalError(self.path, str(e))
blob = Blob(img_data)
image = Image(blob)
# Check if the whole image should be used and cropped if necessary.
src_width = image.size().width()
src_height = image.size().height()
if self.width != src_width or self.height != src_height:
box = Geometry(self.width, self.height, self.x_min_src,
self.y_min_src)
image.crop(box)
# Estimates the size in Bytes of this image part by scaling the number
# of Bytes read with the ratio between the needed part of the image and
# its actual size.
self.estimated_size = bytes_read * abs(
float(self.width * self.height) / float(src_width * src_height))
return image
def specificRecord(theId):
# Get the record.
aRow = db.session.query(ServiceRecord, Vehicle).filter_by(id=theId).join(Vehicle).first()
aRecord = {
"id": aRow[0].id,
"year": aRow[1].year,
"make": aRow[1].make,
"model": aRow[1].model,
"date": aRow[0].date,
"miles": aRow[0].miles,
"description": aRow[0].description
}
# Get the filepaths for the photos.
import os
aPostfix = "vehicles/receipts/{}".format(theId)
aList = [url_for("static", filename=aPostfix + os.sep + x) for x in os.listdir("app/static/" + aPostfix)]
# Create the form.
aForm = PhotoForm()
# Check to see if the form is valid as well as a post request.
if aForm.validate_on_submit():
filename = secure_filename(aForm.upload.data.filename)
aSavePath = 'app/static/vehicles/receipts/{}/'.format(theId) + filename
aForm.upload.data.save(aSavePath)
# Convert the photo to nice web stuff.
from pgmagick import Image, InterlaceType
aImg = Image(aSavePath)
aImg.quality(80)
aImg.scale("80%")
aImg.interlaceType(InterlaceType.PlaneInterlace)
aImg.write(aSavePath)
flash("File uploaded", "success")
aForm = PhotoForm()
return render_template(
"vehicles/record.html",
theRecord=aRecord,
theFiles=aList,
theForm=aForm
)
def test_scale_jpeg(self):
img = api.Image((400, 400), 'blue')
img.write(self.tmp_filename_jpg)
img2 = Image(Blob(open(self.tmp_filename_jpg).read()),
Geometry(200, 200))
img2.scale('200x200')
img2.write(self.tmp_filename_jpg)
def _watermark(self, image, watermark_path, opacity, size, position_str):
with open(watermark_path, 'rb') as watermark_file:
watermark = self.get_image(watermark_file)
image_size = self.get_image_size(image)
layer = Image(Geometry(image_size[0], image_size[1]), 'transparent')
if opacity < 1:
self._reduce_opacity(watermark, opacity)
if not size:
mark_size = self.get_image_size(watermark)
else:
mark_size = tuple(
self._get_new_watermark_size(size,
self.get_image_size(watermark)))
options = {
'crop': 'center',
'upscale': mark_size > self.get_image_size(watermark)
}
watermark = self.scale(watermark, mark_size, options)
watermark = self.crop(watermark, mark_size, options)
if position_str == 'tile':
for x_pos in range(0, image_size[0], mark_size[0]):
for y_pos in range(0, image_size[1], mark_size[1]):
layer.composite(watermark, x_pos, y_pos,
CoOp.OverCompositeOp)
else:
position = self._define_watermark_position(position_str,
image_size, mark_size)
layer.composite(watermark, position[0], position[1],
CoOp.OverCompositeOp)
image.composite(layer, 0, 0, CoOp.OverCompositeOp)
return image
def get_image(self):
# Open the image
try:
img_file = urlopen(self.path)
img_data = img_file.read()
bytes_read = len(img_data)
except HTTPError as e:
raise ImageRetrievalError(self.path, "Error code: %s" % e.code)
except URLError as e:
raise ImageRetrievalError(self.path, e.reason)
blob = Blob(img_data)
image = Image(blob)
# Check if the whole image should be used and cropped if necessary.
src_width = image.size().width()
src_height = image.size().height()
if self.width != src_width or self.height != src_height:
box = Geometry(self.width, self.height, self.x_min_src,
self.y_min_src)
image.crop(box)
# Estimates the size in Bytes of this image part by scaling the number
# of Bytes read with the ratio between the needed part of the image and
# its actual size.
self.estimated_size = bytes_read * abs(
float(self.width * self.height) / float(src_width * src_height))
return image
def getpixels_test_template(self, use_const):
img = Image(Geometry(300, 200), Color('transparent'))
getPixelsMethod = img.getConstPixels if use_const else img.getPixels
pixels = getPixelsMethod(40, 50, 10, 10)
self.assertEqual(10 * 10, len(pixels))
with self.assertRaises(IndexError):
pixels[2000]
colorMax = Color.scaleDoubleToQuantum(1.0)
self.assertEqual(0, pixels[0].red)
self.assertEqual(0, pixels[0].blue)
self.assertEqual(0, pixels[0].green)
self.assertEqual(colorMax, pixels[0].opacity)
return pixels
def _composite(self, mask, pic, i=0):
"""
composite of mask and pic. also trims it and renames with offset.
"""
base = GMImage(pic)
layer = GMImage(mask)
base.composite(layer, 0, 0, co.CopyOpacityCompositeOp)
finished_clip_filename = os.path.join(
self.target_directory, self.junk_dir,
"%s-%s.png" % (os.path.basename(pic), os.path.basename(mask)))
base.write(finished_clip_filename)
box = self._trim(
finished_clip_filename,
os.path.join(self.target_directory, self.raster_dir, "%i.png" % i))
self._potrace(mask,
i=i,
trimmedpng=os.path.join(self.target_directory,
self.raster_dir, "%i.png" % i))
self.pieces[i] = box
def test_scale_jpeg(self):
img = api.Image((400, 400), 'blue')
img.write(self.tmp_filename_jpg)
with open(self.tmp_filename_jpg, 'rb') as fp:
b = Blob(str(fp.read()))
img2 = Image(b, Geometry(200, 200))
if sys.platform.lower() == 'darwin':
# NOTE: error occur when use '200x200' param
# -----------------------------------------------------
# RuntimeError: Magick: Application transferred too few
# scanlines (x.jpg) reported by coders/jpeg.c:344 (JPEGErrorHandler)
img2.scale('199x199')
else:
img2.scale('200x200')
img2.write(self.tmp_filename_jpg)
def pdf_to_image(self, pdf_file):
if not self.check_file_exist(pdf_file):
self.log.debug('Requested file not found in {} '.format(pdf_file))
return False
image_file = pdf_file.replace('.pdf', '.jpg')
try:
pdf_to_img = Image()
pdf_to_img.density('200')
pdf_to_img.read(pdf_file)
pdf_to_img.write(image_file)
self.log.info('Image convert passed - {} '.format(image_file))
return True
except Exception:
self.log.error('Image convert failed - {} '.format(image_file))
self.log.error('', exc_info=True)
return False
def test_image_setpixels(self):
img = Image(Geometry(300, 200), Color('transparent'))
pixels = img.setPixels(40, 50, 5, 5)
for pixel in pixels:
pixel.red = 50
img.syncPixels()
for pixel in img.getPixels(40, 50, 5, 5):
self.assertEqual(50, pixel.red)
def convert_split(srcfile='', dstpath='', truefile='', split='3x3', w=100, h=100):
"""
目前仅用作封面频道
"""
srcfile = srcfile.encode("utf-8")
dstpath = dstpath.encode("utf-8")
truefile = truefile.encode("utf-8")
(sp_x, sp_y) = split.split('x')
(file_name, image_ext) = os.path.splitext(os.path.basename(srcfile))
cw = int(sp_x) * int(w)
ch = int(sp_y) * int(h)
t1 = time.time()
#生成封面列表图
re = myGraphicsMagick.convert_gif_thumbnail_frame0_g(srcfile=srcfile, dstfile=truefile, w=cw, h=ch,
need_return=False)
if re == True:
#切割方式为从图片的左上开始逐行切割
#目标图片文件名为：50d8059b1a822.11.jpg
blobData = Blob(open(srcfile).read())
try:
num = 0#图片输出的编号
for j in range(int(sp_y)):
if ( num >= ( int( sp_x )*int( sp_y ) - 1 ) ):
break
for i in range(int(sp_x)):
img = Image( blobData, Geometry(cw,ch) )
linePos = i * int(w)
colsPos = j * int(h)
#从指定的像素点进行裁剪
img.crop( Geometry(w,h,linePos, colsPos) )
destFilename = dstpath+'/%s.%d.%s' %( file_name,num,image_ext )
img.profile("*",Blob())
img.write( destFilename )
num = num + 1
t2 = time.time()
sys.stdout.writelines(datetime.now().strftime('%Y-%m-%d %H:%M:%S ')+"libconvert appName:%s ver:%s cmdSN:%s type:%s cmdData:%s command : convert_split srcfile:%s dstfile:%s runTime:%s\n" % ( proto.protocal['appName'],proto.protocal['ver'],proto.protocal['cmdSN'],proto.protocal['type'],proto.protocal['cmdData'], srcfile,dstfile,(t2-t1)) )
sys.stdout.flush()
return ret
except Exception as e:
sys.stderr.writelines(datetime.now().strftime('%Y-%m-%d %H:%M:%S ')+"libconvert_split %s %s srcfile:%s destFilename:%s\n" % (e.args, e.message, srcfile,destFilename))
sys.stderr.flush()
return 'False'
else:
return "False"
pass
return 'True'
def post(self):
# check pic exgister
if self.request.files == {} or 'pic' not in self.request.files:
self.write('<script>m_ksb_msg.show("请选择图片")</script>')
return
# check pic format
image_type_list = ['image/gif', 'image/jpeg', 'image/pjpeg', 'image/bmp', 'image/png', 'image/x-png']
send_file = self.request.files['pic'][0]
if send_file['content_type'] not in image_type_list:
self.write('<script>m_ksb_msg.show("仅支持jpg,jpeg,bmp,gif,png格式的图片！")</script>')
return
# check pic size 4M
if len(send_file['body']) > 4 * 1024 * 1024:
self.write('<script>m_ksb_msg.show("请上传4M以下的图片");</script>')
return
# create temp file
tmp_file = tempfile.NamedTemporaryFile(delete=True)
tmp_file.write(send_file['body'])
tmp_file.seek(0)
# illegal pic can't open with Image
try:
image_one = Image(tmp_file.name)
except IOEturerror:
logging.info(error)
logging.info('+'*30 + '\n')
logging.info(self.request.headers)
tmp_file.close()
self.write('<script>m_ksb_msg.show("图片不合法！")</script>')
return
# check pixel
if image_one.columns() < 250 or image_one.rows() < 250 or \
image_one.columns() > 2000 or image_one.rows() > 2000:
tmp_file.close()
self.write('<script>m_ksb_msg.show("图片长宽在250px~2000px之间！")</script>')
return
# saving
image_path = "./static/pic/goods/"
image_format = send_file['filename'].split('.').pop().lower()
tmp_name = image_path + str(int(time.time())) + image_format
image_one.write(tmp_name)
# close temp
tmp_file.close()
self.write('<script>m_ksb_msg.show("文件上传成功，路径为：" + image_path[1:])</script>')
return
def convertGMtoPIL(gmimage):
"""
Convert GraphicsMagick image to PIL
work with grayscale and colour
"""
img = Image(gmimage) # make copy
gmimage.depth(8)
img.magick("RGB")
w, h = img.columns(), img.rows()
blob = Blob()
img.write(blob)
data = blob.data
# convert string array to an RGB PIL image
pilimage = PilImage.fromstring('RGB', (w, h), data)
return pilimage
def process_images(subdir):
curr_dir = data_dir + subdir + '/'
counter = 1
files = os.listdir(curr_dir)
interval = int(len(files) / target)
for file in files:
if counter % interval == 0 and counter / interval <= target:
img = Image(curr_dir + '/' + file)
img.type(ImageType.GrayscaleType)
img.write(out_dir + subdir + str(counter / interval) + '.tif')
counter = counter + 1
def to_jpgs(self, size='mid', pages=None):
""" Convert pdf to jpeg images
pages: array for pages, None for extract all
"""
dendic = dict(thumb=40, mid=100, big=150)
density = dendic[size]
pages = np.arange(0, self.pages, 1) if pages is None else pages
if len(pages) < 1:
return
sp = self.slides_path(size)
if os.path.exists(sp):
shutil.rmtree(sp)
os.makedirs(sp)
img = Image()
img.density("{}".format(density))
for page in pages:
if page > self.pages or page < 0:
continue
pdf = "{}[{}]".format(self.pdf_path, page)
slid = "{}/{:03d}".format(sp, page)
img.read(pdf)
img.write("{}.jpg".format(slid))
def get_image(self):
# Open the image
try:
img_file = urllib.urlopen(self.path)
except urllib.HTTPError as e:
raise ImageRetrievalError(self.path, "Error code: %s" % e.code)
except urllib.URLError as e:
raise ImageRetrievalError(self.path, e.reason)
blob = Blob(img_file.read())
image = Image(blob)
# Check if the whole image should be used and cropped if necessary.
src_width = image.size().width()
src_height = image.size().height()
if self.width != src_width or self.height != src_height:
box = Geometry(self.width, self.height, self.x_min_src,
self.y_min_src)
image.crop(box)
return image
