def qrcode_img(text):
image_file = io.StringIO()
image = qrencode.encode_scaled(text, size=300)[2]
image.save(image_file, "ppm")
image_contents = image_file.getvalue()
image_file.close()
return image_contents
def qrCode(self, size=80, level='L', formt=None, asURI=True):
'''Return the QR code of the address. If `formt` is None, the method
returns a PIL Image object, otherwise it returns a string containing
the image in the desired format (e.g. 'PNG').
The level can be one of 'L', 'M', 'Q' or 'H'.
If `asURI` is True, encode the address's "bitcoin:" URI, otherwise
encode the raw address.
This method needs the qrencode module, and returns None if the
module is not found.'''
try:
from qrencode import encode_scaled, QR_ECLEVEL_L, QR_ECLEVEL_M, \
QR_ECLEVEL_Q, QR_ECLEVEL_H
except ImportError:
return None
lvl = {'L': QR_ECLEVEL_L, 'M': QR_ECLEVEL_M, 'Q': QR_ECLEVEL_Q, \
'H': QR_ECLEVEL_H}[level]
if asURI:
data = self.uri()
else:
data = self.address
im = encode_scaled(data, size, level=lvl)[2]
if formt is None:
return im
else:
from StringIO import StringIO
buf = StringIO()
im.save(buf, formt)
result = buf.getvalue()
buf.close()
return result
def make_qr_code(self):
'''
Make a QR code for the book. This could be useful somewhere I guess.
It contains the ISBN, title and Authors of the book.
Maybe it should contain the owner name , yes YOU, just in case you ever need
to split up you and your parter's books. You know why that might be
needed.
TODO. Maybe print the ISBN too.
Change output dir
DONE: Store images in the DB
'''
from db_queries import sql as sql
db_query = sql()
if QR_CODE:
import getpass
user = getpass.getuser()
# Do the QR thang
qr_data = 'ISBN:'+ str(self.abook.id) \
+ ';TITLE:' + str(self.abook.title) \
+ ';AUTHORS:' + str(self.abook.authors) \
+ ";OWNER:" + user
qr = qrencode.encode(qr_data)
# Rescale using the size and add a 1 px border
size = qr[1]
qr = qrencode.encode_scaled(qr_data, (size*3)+2)
img = qr[2]
count = db_query.get_qrcode_count(self.abook.id)
if count == 0:
sql = 'INSERT INTO qrcodes(caption,img) VALUES(%s,%s)' # But how to get them back out again? See below.
args = ("ISBN: " + str(self.abook.id), img, )
self.cur.execute (sql, args)
self.db.commit()
def do_export(args):
"""
The export command. With it you can export your gpg secret
key to a base64 encoded string across n files, or into n qrcodes that
collectivley form your key.
"""
outfile_name = args.outfile_name.split('.')
outfile_ext = 'txt'
if len(outfile_name) > 1:
(outfile_name, outfile_ext) = outfile_name
else:
outfile_name = outfile_name[0]
secret = subprocess.Popen(['gpg', '--export-secret-key', args.keyid], stdout=subprocess.PIPE)
paperkey = subprocess.check_output(['paperkey', '--output-type', 'raw'], stdin=secret.stdout)
base64str = base64.b64encode(paperkey)
chunks = chunk_up(base64str, args.numfiles)
for i, chunk in enumerate(chunks):
if args.png:
(_, _, image) = qrencode.encode_scaled(chunk, int(args.size))
image.save('%s%d.png' % (outfile_name, i+1), 'PNG')
if args.base64:
with open('%s%d.%s' % (outfile_name, i+1, outfile_ext), 'wb') as txt_file:
txt_file.write(chunk)
def run():
conn = bitcoinrpc.connect_to_local()
info = conn.getinfo()
print "Blockcount: %i" % info.blocks
print "Connections: %i" % info.connections
print "Difficulty: %f" % info.difficulty
for ac in conn.listaccounts():
print
bal = conn.getbalance(ac)
print "Account: '%s'. Balance: %s" % (ac, bal)
txs = conn.listtransactions(ac)
for tx in txs:
txid = tx.txid
print "transaction:", tx.amount, "to", tx.address, "|", txid
print
print "Multisig 2 of 3:",
#t = conn.proxy.listunspent()
#print t
multisig = gen_2of3(conn, "mrvQxKbe321W58xaTs65YS6mvUVGQyP52B", \
"03b08df6e673619b93fc0dd39be70d7bf56873241fcfde9e87332d79b87de80fcd", "023d7a2768855435b221003cb23f26d950a4ee22f3d47c9833778326d221253afc")
print multisig
print
print "RECIEVED?"
check = check_rcv_2of3(conn, multisig, 0.1, searchdepth = 100)
print check
if not check[0]:
print "ERROR: didn't received payment at %s" % multisig
return
print
target_addr = "myKPhLdmfk6Ss8j6ugqCVwsC3bcUHpZCg5"
amount = 0.1
print "RELEASE %s BTC to %s" % (amount, target_addr)
_, txid, voutid = check
partial_tx = gen_partial_tx(conn, target_addr, txid, voutid, amount)
print partial_tx
print
print "SIGNING RAW TX"
# by default, uses all available private keys
signed_partial_tx = sign_rawtx(conn, partial_tx)
print signed_partial_tx
print
fn = "qr.png"
print "GENERATING QR CODE for partial transaction: %s" % fn
import qrencode as qr
qrdata = signed_partial_tx.decode("hex").encode("base64")
qrcode = qr.encode_scaled(qrdata, 512)
qrcode[2].save(fn, format="png")
print
server_url = "http://10.200.1.73/multisig"
order_id = "123"
order_descr = "test bestellung 123"
uri = gen_uri(server_url, order_id, order_descr)
print "URI:", uri
def qrcode_img(text):
image_file = StringIO.StringIO()
image = qrencode.encode_scaled(text, size=300)[2]
image.save(image_file, "ppm")
image_contents = image_file.getvalue()
image_file.close()
return image_contents
def main():
parser = OptionParser(usage="usage: %prog [options] text")
parser.add_option("-o",
"--output",
dest="output_filename",
help="write output to FILE",
metavar="FLIE",
default="output.svg")
parser.add_option("-l",
"--logo",
dest="logo_svg",
help="load logo (partial svg file) from FILE",
metavar="FILE")
parser.add_option("-L",
"--logo-raster",
dest="logo_png",
help="load rasterized logo (png) from FILE",
metavar="FILE")
parser.add_option("-c",
"--color",
dest="colour",
default="#a54024",
help="use COLOR as secondary color")
parser.add_option("-m",
"--min-size",
type="int",
dest="min_size",
default="40",
help="pad output to minimum size for final QR image")
(options, args) = parser.parse_args()
if not args:
parser.print_help()
sys.exit()
qr = encode_scaled(args[0], options.min_size, level=QR_ECLEVEL_H)
image = qr[-1]
array = image.load()
# assume squares
size = image.size[0]
class BlogGridQR(BlobGrid):
def get_value(self, x, y):
if not (0 <= x < size) or not (0 <= y < size):
return 0
return 1 - array[x, y] / 255
clear_logo_space(array, size, options.logo_png)
blob_grid = BlogGridQR(size)
output = svg_start(size, options.colour)
output += blob_grid.draw_blobs()
output += get_svg_logo(options.logo_svg)
output += svg_end()
output_file = open(options.output_filename, 'w')
output_file.write(output)
output_file.close()
def create_qrcode(self, fpr):
box = self.rightVBox.get_allocation()
if box.width < box.height:
size = box.width - 30
else:
size = box.height - 30
version, width, image = encode_scaled('OPENPGP4FPR:'+fpr,size,0,1,2,True)
return image
def qr():
data = request.args.get('data', '')
from StringIO import StringIO
img_io = StringIO()
import qrencode as qr
img = qr.encode_scaled(data, 256)
img[2].save(img_io, 'PNG')
img_io.seek(0)
return send_file(img_io, mimetype='image/png')
def build(self):
"""Wraps `qrencode.encode`."""
return qrencode.encode_scaled(
data=self.code,
hint=qrencode.QR_MODE_8,
case_sensitive=True,
version=0, # FIXME: should possibly be fixed
size=self.size,
)
def QRCode(request, invoiceid):
# Generate our URL to put in the QR Code.
url = "http://" + settings.HOSTNAME + reverse('tickets:ticket', args=(invoiceid,))
image = qr.encode_scaled(url, 200)
# serialize to HTTP response
response = HttpResponse(content_type="image/png")
image[2].save(response, "PNG")
return response
def qr():
data = request.args.get('data', '')
from StringIO import StringIO
img_io = StringIO()
import qrencode as qr
img = qr.encode_scaled(data, 256)
img[2].save(img_io, 'PNG')
img_io.seek(0)
return send_file(img_io, mimetype='image/png')
def create(self):
BtBaseDialog.create(self)
self.qrcode_image = self.builder.get_object('qrcode_image')
self.qrcode_fullaccess = self.builder.get_object('qrcode_fullaccess')
self.qrcode_readaccess = self.builder.get_object('qrcode_readaccess')
version, size, image = qrencode.encode_scaled(
'btsync://{0}?n={1}'.format(self.rosecret, self.basename), 232)
self.roqrcode = self.image_to_pixbuf(image)
if self.rwsecret is None:
self.qrcode_image.set_from_pixbuf(self.roqrcode)
self.qrcode_readaccess.set_active(True)
self.qrcode_readaccess.set_sensitive(False)
self.qrcode_fullaccess.set_sensitive(False)
else:
version, size, image = qrencode.encode_scaled(
'btsync://{0}?n={1}'.format(self.rwsecret, self.basename), 232)
self.rwqrcode = self.image_to_pixbuf(image)
self.qrcode_image.set_from_pixbuf(self.rwqrcode)
self.qrcode_fullaccess.set_active(True)
def qrcode(self, req):
app = self.app
_, _, im = encode_scaled(data=app.api, size=190)
io = StringIO()
im.save(io, "JPEG", quality=100)
resp = req.response
resp.set_content_type("image/jpeg")
resp.set_header("Cache-Control", "max-age=%d" % (365 * 24 * 60 * 60))
resp.set_header("Expires", "Wed, 01 Jan 2020 00:00:00 GMT")
if "pragma" in resp.headers:
del resp.headers["pragma"]
return io.getvalue()
def bookQr(book):
'''save qr representation of book class to
./tmp/$ID.png
returns relative path to image file
'''
if not exists('./tmp'):
mkdir('./tmp')
filename = "./tmp/%s.jpg" %unicode(book.ID)
fileout = open(filename, 'w')
im = encode_scaled(unicode(book.__repr__()), 2)[2]
im.save(fileout)
return filename
def create(self):
BtBaseDialog.create(self)
self.qrcode_image = self.builder.get_object('qrcode_image')
self.qrcode_fullaccess = self.builder.get_object('qrcode_fullaccess')
self.qrcode_readaccess = self.builder.get_object('qrcode_readaccess')
version, size, image = qrencode.encode_scaled(
'btsync://{0}?n={1}'.format(self.rosecret,self.basename),232
)
self.roqrcode = self.image_to_pixbuf(image)
if self.rwsecret is None:
self.qrcode_image.set_from_pixbuf(self.roqrcode)
self.qrcode_readaccess.set_active(True)
self.qrcode_readaccess.set_sensitive(False)
self.qrcode_fullaccess.set_sensitive(False)
else:
version, size, image = qrencode.encode_scaled(
'btsync://{0}?n={1}'.format(self.rwsecret,self.basename),232
)
self.rwqrcode = self.image_to_pixbuf(image)
self.qrcode_image.set_from_pixbuf(self.rwqrcode)
self.qrcode_fullaccess.set_active(True)
def get_qr_feature_by_id(request, feature_id, collection_name=None):
"""
Return QR code image matching the geographic feature matching
feature_id.
"""
json_response = get_document_by(request, id=feature_id, search_in=('url',),
collection_name=collection_name)
jr=json.loads(json_response.content)
if jr['status'] != 200:
return json_response
response = HttpResponse(mimetype="image/png")
image = qrencode.encode_scaled(json_response.content, 400)
image[2].save(response, "PNG")
return response
def qr(req):
texto = req.GET["texto"]
dat = qrencode.encode_scaled(texto,200)[2]
dat.save("codigoQR.jpg")
response = HttpResponse(content_type='image/jpeg')
if "descargar" in req.GET:
response['Content-Disposition'] = 'attachment; filename="codigoQR.jpg"'
archivo = open("codigoQR.jpg", "r")
fin = False
while not fin:
caracter = archivo.read(1)
if caracter == "":
fin = True
else:
response.write(caracter)
archivo.close()
return response
def qrcode( request, server ):
""" Show a QR Coce image that links to the server's embedded page. """
try:
import qrencode
except ImportError:
return HttpResponse( "oh noez" )
else:
from django.contrib.sites.models import Site
version, size, img = qrencode.encode_scaled( "%s://%s%s" % (
{ False: "http", True: "https" }[request.is_secure()],
Site.objects.get_current().domain,
reverse( embed, kwargs={ 'server': server } )
), 82 )
buf = StringIO()
img.save( buf, "PNG" )
return HttpResponse( buf.getvalue(), "image/png" )
def create_qr_code(invoice_id, invoice_total ,exch_rate):
'''
Create and save a QR code.
@param invoice_id
@param invoice_total
@param exch_rate
'''
qr_data = 'bitcoin:' \
+ get_bitcoin_address('Work Done')[0] \
+ '?amount=' + str(round(invoice_total/exch_rate,8)) \
+ "&label=" + get_bitcoin_address('Work Done')[1] # FIXME: Search term shouldn't be hard coded here
qr = qrencode.encode(qr_data)
# Rescale using the size and add a 1 px border
size = qr[1]
qr = qrencode.encode_scaled(qr_data, (size*4))
img = qr[2] #'invoice-' + str(invoice_id) +'.png'
img.save('qr.png', 'png')
def create_signature(self, data):
if (self._sign_org['private_key'] is None):
raise Exception('No private key available for signing. Load private key first.')
if (self._sign_org['uuid'] is None):
raise Exception('No Organization UUID available. Set the Organization UUID first')
timestamp = datetime.datetime.now().replace(microsecond = 0)
timestamp_str = unicode(timestamp) + (u' UTC%s' % u'-' if time.timezone > 0 else u'+') + unicode(abs(time.timezone / 60 / 60))
data_copy = data.copy()
data_copy[u"pt_timestamp"] = timestamp_str
data_copy[u"org_uuid"] = self._sign_org['uuid']
data_list_str = self.__data_to_string(data_copy)
data_sig = self.__sign_string(data_list_str)
#data_list_str += u'!' # test altering the data after signature is created
data_str = self.PREAMBLE + self.ENTRY_DELIMITER
data_str += data_list_str
data_str += u'%s%s' % (self.ENTRY_DELIMITER, unicode(data_sig))
qr_code = qrencode.encode_scaled(data_str.encode('utf-8').encode('base64'), 200)
return qr_code[2]
def main():
parser = OptionParser(
usage="usage: %prog [options] text")
parser.add_option("-o", "--output", dest="output_filename",
help="write output to FILE", metavar="FLIE", default="output.svg")
parser.add_option("-l", "--logo", dest="logo_svg",
help="load logo (partial svg file) from FILE", metavar="FILE")
parser.add_option("-L", "--logo-raster", dest="logo_png",
help="load rasterized logo (png) from FILE", metavar="FILE")
parser.add_option("-c", "--color", dest="colour", default="#a54024",
help="use COLOR as secondary color")
parser.add_option("-m", "--min-size", type="int", dest="min_size",
default="40", help="pad output to minimum size for final QR image")
(options, args) = parser.parse_args()
if not args:
parser.print_help()
sys.exit()
qr = encode_scaled(args[0], options.min_size, level=QR_ECLEVEL_H)
image = qr[-1]
array = image.load()
# assume squares
size = image.size[0]
class BlogGridQR(BlobGrid):
def get_value(self, x, y):
if not (0 <= x < size) or not (0 <= y < size):
return 0
return 1 - array[x, y] / 255
clear_logo_space(array, size, options.logo_png)
blob_grid = BlogGridQR(size)
output = svg_start(size, options.colour)
output += blob_grid.draw_blobs()
output += get_svg_logo(options.logo_svg)
output += svg_end()
output_file = open(options.output_filename, 'w')
output_file.write(output)
output_file.close()
def make_qr_code(self):
'''
Make a QR code for the book. This could be useful somewhere I guess.
It contains the ISBN, title and Authors of the book.
Maybe it should contain the owner name , yes YOU, just in case you ever need
to split up you and your parter's books. You know why that might be
needed.
TODO. Maybe print the ISBN too.
Change output dir
DONE: Store images in the DB
'''
from db_queries import sql as sql
db_query = sql()
if QR_CODE:
import getpass
user = getpass.getuser()
# Do the QR thang
qr_data = 'ISBN:'+ str(self.abook.id) \
+ ';TITLE:' + str(self.abook.title) \
+ ';AUTHORS:' + str(self.abook.authors) \
+ ";OWNER:" + user
qr = qrencode.encode(qr_data)
# Rescale using the size and add a 1 px border
size = qr[1]
qr = qrencode.encode_scaled(qr_data, (size*3)+2)
img = qr[2]
count = db_query.get_qrcode_count(self.abook.id)
if count == 0:
sql = 'INSERT INTO qrcodes(caption,img) VALUES(%s,%s)' # But how to get them back out again? See below.
args = ("ISBN: " + str(self.abook.id), img, )
self.cur.execute (sql, args)
self.db.commit()
#pixmap,mask = pixbuf.render_pixmap_and_mask()
#img.save('tmp.png', 'png')
# Display it in the GUI
#self.qr_img.set_from_image(img, mask) # may need to be gtk.image
#self.qr_img.set_from_file('tmp.png') # fix this, I don't like using tmp files
'''
def activate(self, leaf, ctx):
"""Create the image from leaf text and display it on window"""
image_file = StringIO.StringIO()
text = leaf.get_text_representation()
version, size, image = qrencode.encode_scaled(text, size=300)
image.save(image_file, "ppm")
image_contents = image_file.getvalue()
image_file.close()
loader = gtk.gdk.PixbufLoader("pnm")
loader.write(image_contents, len(image_contents))
pixbuf = loader.get_pixbuf()
loader.close()
window = gtk.Window()
window.set_default_size(350, 350)
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
image.show()
window.add(image)
ctx.environment.present_window(window)
def activate(self, leaf, ctx):
"""Create the image from leaf text and display it on window"""
image_file = StringIO.StringIO()
text = leaf.get_text_representation()
version, size, image = qrencode.encode_scaled(text, size=300)
image.save(image_file, "ppm")
image_contents = image_file.getvalue()
image_file.close()
loader = gtk.gdk.PixbufLoader("pnm")
loader.write(image_contents, len(image_contents))
pixbuf = loader.get_pixbuf()
loader.close()
window = gtk.Window()
window.set_default_size(350, 350)
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
image.show()
window.add(image)
ctx.environment.present_window(window)
def genQR(self, text, size = 500, mask = None, icon = None):
# Create QRCode
self._text = text
hQR = qrencode.encode_scaled(unicode(text), size, level=3)
# Merge colored mask with QRCode
if mask is not None:
hQR = hQR[2]
try:
foreground = Image.open(mask)
except:
foreground = Image.new('RGB', (size, size), (0, 0, 0))
# Resize mask if size is not equal to qrcode size
if foreground.size[0] != size:
foreground = foreground.resize((size, size), Image.ANTIALIAS)
mask = Image.new('L', (size, size), color=255) # color=255 -> keep white pixel
hQR = Image.composite(mask, foreground, hQR)
else:
hQR = hQR[2]
# Add icon
if icon is not None:
hIcon = Image.open(icon)
# Resize icon if too big
if hIcon.size[0] > int(size * 0.30):
new_size = int(size * 0.30)
hIcon = hIcon.resize((new_size, new_size), Image.ANTIALIAS)
posX = (size / 2) - (hIcon.size[0] / 2)
posY = (size / 2) - (hIcon.size[1] / 2)
try:
hQR.paste(hIcon, (posX, posY), mask=hIcon)
except:
hQR.paste(hIcon, (posX, posY))
# Save QRCode to stream and keep into class
self._stream.seek(0)
hQR.save(self._stream, 'png')
self._picture = hQR
def qr():
text = request.args['text']
image = qrencode.encode_scaled(text, 120)[2]
image = image.convert('RGB')
recoloured = []
for pixel in image.getdata():
if pixel == (255, 255, 255):
pixel = (0, 192, 0)
recoloured.append(pixel)
image.putdata(recoloured)
output = StringIO.StringIO()
format = 'PNG'
image.save(output, format)
contents = output.getvalue()
output.close()
response = make_response(contents)
response.headers['Content-Type'] = 'image/png'
return response
def build_ticket(ticket, owner = None, \
background = "ticket-template.pdf", \
ticket_x = 2.58, ticket_y = 5.93, ticket_size = 3.14, \
ticket_print_as_string = True, ticket_sx = 7.2, ticket_sy = 7.5,
owner_x = 7.2, owner_y = 7):
tempImg = tempfile.mkstemp()
tempName = tempImg[1]
qr_item = qrencode.encode_scaled(ticket, 200, level=qrencode.QR_ECLEVEL_H)
qr_item[2].save(tempName, "PNG")
overlayData = StringIO()
overlay = canvas.Canvas(overlayData, pagesize=A4, bottomup=0)
if owner != None:
overlay.setFont('Helvetica', 20)
overlay.drawString(owner_x * cm, owner_y * cm, owner)
if ticket_print_as_string:
overlay.setFont('Courier', 8)
overlay.drawString(ticket_sx * cm, ticket_sy * cm, ticket)
overlay.drawImage(tempName, ticket_x * cm, ticket_y * cm, ticket_size * cm, ticket_size * cm)
overlay.save()
page = PdfFileReader(file(background,"rb")).getPage(0)
overlayPage = PdfFileReader(StringIO(overlayData.getvalue())).getPage(0)
page.mergePage(overlayPage)
outputFile = tempfile.mkstemp()
output = PdfFileWriter()
output.addPage(page)
output.write(file(outputFile[1],"w"))
os.remove(tempName)
return outputFile
def create_qrcode(data, size):
'''Creates a PIL image for the data given'''
log.debug('Encoding %s', data)
version, width, image = encode_scaled(data,size,0,1,2,True)
return image
def __init__(self, h, w, rows=3, columns=4, homogenous=False):
gtk.Table.__init__(self, rows, columns, homogenous)
if w/4 > h - (w/3):
d = h - (w/3)
else:
d = w/4
titlesvg = PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/labeltitle.svg'
titlepixbuf = gtk.gdk.pixbuf_new_from_file_at_size(titlesvg, width= int(w), height=-1)
titleImage = gtk.Image()
titleImage.set_from_pixbuf(titlepixbuf)
titleAlign = gtk.Alignment(0.5, 0, 0, 0)
titleAlign.add(titleImage)
wifisvg = PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/labelwifi.svg'
wifipixbuf = gtk.gdk.pixbuf_new_from_file_at_size(wifisvg, width= int(w/4), height=-1)
wifiImage = gtk.Image()
wifiImage.set_from_pixbuf(wifipixbuf)
wifiAlign = gtk.Alignment(0.5, 1, 0, 0)
wifiAlign.add(wifiImage)
connectsvg = PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/labelconnect.svg'
connectpixbuf = gtk.gdk.pixbuf_new_from_file_at_size(connectsvg, width= int(w/4), height=-1)
connectImage = gtk.Image()
connectImage.set_from_pixbuf(connectpixbuf)
connectAlign = gtk.Alignment(0.5, 1, 0, 0)
connectAlign.add(connectImage)
uploadsvg = PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/labelupload.svg'
uploadpixbuf = gtk.gdk.pixbuf_new_from_file_at_size(uploadsvg, width= int(w/4), height=-1)
uploadImage = gtk.Image()
uploadImage.set_from_pixbuf(uploadpixbuf)
uploadAlign = gtk.Alignment(0.5, 1, 0, 0)
uploadAlign.add(uploadImage)
startsvg = PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/labelstart.svg'
startpixbuf = gtk.gdk.pixbuf_new_from_file_at_size(startsvg, width= int(w/4), height=-1)
startImage = gtk.Image()
startImage.set_from_pixbuf(startpixbuf)
startAlign = gtk.Alignment(0.5, 1, 0, 0)
startAlign.add(startImage)
wifiQR = qrencode.encode_scaled('WIFI:T:WPA;S:' + PRES_CONFIG.NW_AP + ';P:' + PRES_CONFIG.NW_PW + ';;', int(d)-80)
wifiQR[2].save(PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/wifiQR.png')
wifiQRImage = gtk.Image()
wifiQRImage.set_from_file(PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/wifiQR.png')
wifiQRAlign = gtk.Alignment(0.5, 0.5, 0, 0)
wifiQRAlign.add(wifiQRImage)
connectQR = qrencode.encode_scaled('http://' + PRES_CONFIG.NW_IP + ':' + PRES_CONFIG.NW_PORT, int(d)-80)
connectQR[2].save(PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/httpQR.png')
connectQRImage = gtk.Image()
connectQRImage.set_from_file(PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/httpQR.png')
connectQRAlign = gtk.Alignment(0.5, 0.5, 0, 0)
connectQRAlign.add(connectQRImage)
uploadimagesvg = PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/imageupload.svg'
uploadimagepixbuf = gtk.gdk.pixbuf_new_from_file_at_size(uploadimagesvg, width= int(d)-80, height=-1)
uploadimageImage = gtk.Image()
uploadimageImage.set_from_pixbuf(uploadimagepixbuf)
uploadimageAlign = gtk.Alignment(0.5, 0.5, 0, 0)
uploadimageAlign.add(uploadimageImage)
startimagesvg = PRES_CONFIG.ABS_PATH(PRES_CONFIG.DIR_MEDIA_GUI) + '/imagestart.svg'
startimagepixbuf = gtk.gdk.pixbuf_new_from_file_at_size(startimagesvg, width= int(d)-80, height=-1)
startimageImage = gtk.Image()
startimageImage.set_from_pixbuf(startimagepixbuf)
startimageAlign = gtk.Alignment(0.5, 0.5, 0, 0)
startimageAlign.add(startimageImage)
self.attach(titleAlign, 0, 4, 0, 1)
self.attach(wifiAlign, 0, 1, 2, 3)
self.attach(connectAlign, 1, 2, 2, 3)
self.attach(uploadAlign, 2, 3, 2, 3)
self.attach(startAlign, 3, 4, 2, 3)
self.attach(wifiQRAlign, 0, 1, 1, 2)
self.attach(connectQRAlign, 1, 2, 1, 2)
self.attach(uploadimageAlign, 2, 3, 1, 2)
self.attach(startimageAlign, 3, 4, 1, 2)
#!/usr/bin/python2.7
# -*- coding: utf-8 -*
#this is qrencode v.1.01 code
#sudo easy_install qrencode
import qrencode
import sys
width = 500
content = sys.argv[1]
(version, size, img) = qrencode.encode_scaled(content,
width,
level=3,
version=5)
img.save('qrcode.png', "PNG")
#!/usr/bin/python2.7
# -*- coding: utf-8 -*
#this is qrencode v.1.01 code
#sudo easy_install qrencode
import qrencode
import sys
width = 500
content = sys.argv[1]
(version, size, img) = qrencode.encode_scaled(content, width, level=3, version=5)
img.save('qrcode.png', "PNG")
def qrcode(request, patient_id):
qrinfo = "https://beheartsmart.com/dashboard/%s" % (patient_id)
response = HttpResponse(mimetype="image/png")
image = qrencode.encode_scaled( qrinfo, 400)
image[2].save(response, "PNG")
return response
def create_qrcode(data, size):
'''Creates a PIL image for the data given'''
log.debug('Encoding %s', data)
version, width, image = encode_scaled(data, size, 0, 1, 2, True)
return image
def show_invoice(self, bitcoin_uri):
(_, size, img) = qrencode.encode_scaled(bitcoin_uri, QR_CODE_SIZE)
buf = StringIO()
img.save(buf, format='PNG')
image_data = "data:image/png,%s" % urllib.quote(buf.getvalue())
self._evaluate_java_script('show_invoice("%s")' % image_data)
try:
db = MySQLdb.connect(db='books', passwd='pu5tu1e')
except:
print "No database connection"
db = False
#db= False # debugging
if db: cur = db.cursor()
cur.execute("select * from books;")
#rows = cur.fetchall()
row = cur.fetchone()
while row is not None:
title = row[1]
authors = row[2]
bar = row[3]
qr = qrencode.encode('ISBN:' + str(bar) + ' TITLE:' + str(title) +
' AUTHORS:' + str(authors))
size = qr[1]
#print size
qr = qrencode.encode_scaled(
'ISBN:' + str(bar) + ' TITLE:' + str(title) + ' AUTHORS:' +
str(authors), size * 2)
img = qr[2]
size = qr[1]
#print size
print str(bar)
img.save('../ISBN:' + str(bar) + '.png', 'png')
row = cur.fetchone()
db.close()
try:
db = MySQLdb.connect(db='books', passwd = 'pu5tu1e');
except:
print "No database connection"
db = False
#db= False # debugging
if db: cur = db.cursor()
cur.execute("select * from books;")
#rows = cur.fetchall()
row = cur.fetchone()
while row is not None:
title = row[1]
authors = row[2]
bar = row[3]
qr = qrencode.encode('ISBN:'+ str(bar) + ' TITLE:' + str(title) + ' AUTHORS:' + str(authors))
size = qr[1]
#print size
qr = qrencode.encode_scaled('ISBN:'+ str(bar) + ' TITLE:' + str(title) + ' AUTHORS:' + str(authors), size*2)
img = qr[2]
size = qr[1]
#print size
print str(bar)
img.save('../ISBN:' + str(bar) + '.png', 'png')
row = cur.fetchone()
db.close()
def encode():
# ver,size,img = qrencode.encode("学你妹的长") #默认大小
ver,size,img = qrencode.encode_scaled("学你妹的长",128) #指定大小
img.save('./code.png')
