def do_GET(self):
try:
self.send_response(200)
self.send_header("Connection", "close")
self.send_header("Max-Age", "0")
self.send_header("Expires", "0")
self.send_header("Cache-Control", "no-cache, private")
self.send_header("Pragma", "no-cache")
self.send_header(
"Content-Type",
"multipart/x-mixed-replace; boundary=--BOUNDARYSTRING")
self.end_headers()
while True:
if self._server.getData() is None:
continue
JpegData = cv.EncodeImage(
".jpeg", self._server.getData(),
(cv.CV_IMWRITE_JPEG_QUALITY, 75)).tostring()
self.wfile.write("--BOUNDARYSTRING\r\n")
self.send_header("Content-type", "image/jpeg")
self.send_header("Content-Length", str(len(JpegData)))
self.end_headers()
self.wfile.write(JpegData)
self.wfile.write("\r\n")
time.sleep(self._server.getSleep())
return
except BaseException as baseerr:
self.send_error(
500, 'PiCam Streaming Server Error: \r\n\r\n%s' % str(baseerr))
def read(self, extension=None, quality=None):
if not extension and FORMATS[self.extension] == 'TIFF':
# If the image loaded was a tiff, return the buffer created earlier.
return self.buffer
else:
if quality is None:
quality = self.context.config.QUALITY
options = None
extension = extension or self.extension
try:
if FORMATS[extension] == 'JPEG':
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
except KeyError:
# default is JPEG so
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
if FORMATS[extension] == 'TIFF':
channels = cv2.split(numpy.asarray(self.image))
data = self.write_channels_to_tiff_buffer(channels)
else:
data = cv.EncodeImage(extension, self.image, options or []).tostring()
if FORMATS[extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(0, ExifSegment(self.exif_marker, None, self.exif, 'rw'))
data = img.writeString()
return data
def read(self, extension=None, quality=None):
if quality is None: quality = self.context.request.quality
options = None
extension = extension or self.extension
if FORMATS[extension] == 'JPEG':
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
return cv.EncodeImage(extension, self.image, options or []).tostring()
def known_image(set_abbrev,name):
base_dir = '/home/talin/Cockatrice/cards/downloadedPics' #'' #YOUR BASE_DIR HERE
sub_path = os.path.join(set_abbrev,name+'.full.jpg')
path = safe_join(base_dir, sub_path)
if os.path.exists(path):
img = cv.LoadImage(path.encode('utf-8'), 0)
return send_file(StringIO(cv.EncodeImage('.PNG',img).tostring()), 'image/png')
else:
return ("img not found", 404)
def known_image(set_abbrev,name):
base_dir = config.base_magic_set_dir
sub_path = os.path.join(set_abbrev,name+'.full.jpg')
path = safe_join(base_dir, sub_path)
if os.path.exists(path):
img = cv.LoadImage(path.encode('utf-8'), 0)
return send_file(StringIO(cv.EncodeImage('.PNG',img).tostring()), 'image/png')
else:
return ("img not found", 404)
def read(self, extension=None, quality=options.QUALITY):
with tempfile.NamedTemporaryFile(suffix=self.extension) as temp_file:
img = self.image
if FORMATS[self.extension] == 'JPEG':
img = cv.DecodeImage(
cv.EncodeImage(".jpeg", img,
[cv.CV_IMWRITE_JPEG_QUALITY, quality]))
cv.SaveImage(temp_file.name, img)
temp_file.seek(0)
return temp_file.read()
def image_callback(msg, t):
(topic, cond) = t
bridge = CvBridge()
img = bridge.imgmsg_to_cv(msg, "bgr8")
data = cv.EncodeImage(".jpeg", img).tostring()
#convert to jpeg
cond.acquire()
images[topic].append(data)
cond.notifyAll()
cond.release()
def repeat():
global capture #declare as globals since we are assigning to them now
global camera_index
global show
frame = cv.QueryFrame(capture)
if show:
cv.ShowImage("w1", frame)
c = cv.WaitKey(50)
if c > -1 and chr(c) == 'q':
print chr(c)
return None
return cv.EncodeImage(".jpeg", frame, [cv.CV_IMWRITE_JPEG_QUALITY, 50])
def acquire_image(self):
""" Take an image and return it as a string
:return: jpg image represented as a string
:rtype: string
"""
frame = cv.QueryFrame(self.camera)
frame = cv.QueryFrame(self.camera)
frame = cv.QueryFrame(self.camera)
frame = cv.QueryFrame(self.camera)
frame = cv.QueryFrame(self.camera)
picture = cv.EncodeImage(".jpg", frame).tostring()
return picture
def convert_to_jpeg(self, nparray):
"""Converts a numpy array to a jpeg cv2.Mat image.
Args:
nparray: A numpy.ndarray of an image.
Returns:
A cv2.Mat jpeg-encoded image.
"""
cvmat = cv.fromarray(nparray)
cvmat = cv.EncodeImage(JPEG_EXTENSION, cvmat)
return cvmat
def read(self, extension=None, quality=None):
if quality is None:
quality = self.context.config.QUALITY
options = None
extension = extension or self.extension
try:
if FORMATS[extension] == 'JPEG':
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
except KeyError:
#default is JPEG so
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
return cv.EncodeImage(extension, self.image, options or []).tostring()
def do_tarfile_save(self, tf):
""" Write images and calibration solution to a tarfile object """
def taradd(name, buf):
s = StringIO.StringIO(buf)
ti = tarfile.TarInfo(name)
ti.size = len(s.buf)
ti.uname = 'calibrator'
ti.mtime = int(time.time())
tf.addfile(tarinfo=ti, fileobj=s)
ims = [("left-%04d.png" % i, im) for i, (_, im) in enumerate(self.db)]
for (name, im) in ims:
taradd(name, cv.EncodeImage(".png", im).tostring())
taradd('ost.txt', self.ost())
def getImage(self, wait=False):
if wait:
i = 0
while not self.cv_image and i < 10:
i += 1
time.sleep(0.1)
image = cv.CreateMat(self.h, self.w, cv.CV_8UC3)
cv.SetZero(image)
if not self.cv_image:
pass
else:
with self.img_lock:
cv.Resize(self.cv_image, image)
return cv.EncodeImage(
".jpeg", image,
[cv.CV_IMWRITE_JPEG_QUALITY, self.quality]).tostring()
def getImage(self,wait=False):
if wait:
i=0
while not self.cv_image and i<10:
i+=1
time.sleep(0.1)
#image=cv2.CreateMat(self.h, self.w, cv.CV_8UC3)
image = np.zeros((self.h, self.w, 3), np.uint8)
#cv.SetZero(image)
while self.cv_image==None:
pass
else:
with self.img_lock:
r = 200.0 / image.shape[1]
dim = (200, int(image.shape[0] * r))
resized = cv2.resize(self.cv_image, dim, interpolation = cv2.INTER_AREA)
#mat_array = cv.fromarray(image)
return cv.EncodeImage(".jpeg", cv.fromarray(resized), [cv.CV_IMWRITE_JPEG_QUALITY, self.quality]).tostring()
def stream(device_name):
device = int(re.findall('[\d+]', device_name)[0])
camera = cv2.VideoCapture(device)
while True:
flag, image_raw = camera.read()
tmp = cv.fromarray(image_raw)
image = cv.EncodeImage('.jpeg', tmp,
(cv.CV_IMWRITE_JPEG_QUALITY, JPEG_QUALITY))
image_data = image.tostring()
yield (b'--bound'
b'Content-Type: image/jpeg\r\n'
b'Content-length: ' + str(len(image_data)) + '\r\n\r\n'
b'' + image_data + ''
b'\r\n')
camera.release()
def captures_to_db(captures, box_name):
#given an iterable of captures and a box name,
#save all the captured images to the database
starting_index = session.query(func.max(InvCard.box_index))\
.filter(InvCard.box==box_name).first()[0]
if starting_index is None:
starting_index = 0
for i, img in enumerate(captures):
as_png = cv.EncodeImage(".png", img).tostring()
InvCard(box=box_name,
box_index=starting_index + i,
scan_png=as_png,
recognition_status="scanned",
inventory_status="present")
session.commit()
def read(self, extension=None, quality=None):
if not extension and FORMATS[self.extension] == 'TIFF':
# If the image loaded was a tiff, return the buffer created earlier.
return self.buffer
else:
if quality is None:
quality = self.context.config.QUALITY
options = None
extension = extension or self.extension
# Check if we should write a JPEG. If we are allowing defaulting to jpeg
# and if the alpha channel is all white (opaque).
channels = None
if getattr(self.context.request, 'default_to_jpeg', True):
channels = cv2.split(numpy.asarray(self.image))
if len(channels) > 3 and numpy.all(channels[3] == 255):
extension = '.jpg'
try:
if FORMATS[extension] == 'JPEG':
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
except KeyError:
# default is JPEG so
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
if FORMATS[extension] == 'TIFF':
channels = channels or cv2.split(numpy.asarray(self.image))
data = self.write_channels_to_tiff_buffer(channels)
else:
data = cv.EncodeImage(extension, self.image, options
or []).tostring()
if FORMATS[
extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(
0, ExifSegment(self.exif_marker, None, self.exif,
'rw'))
data = img.writeString()
return data
def do_GET(self):
global cameraQuality
try:
self.path=re.sub('[^.a-zA-Z0-9]', "",str(self.path))
if self.path=="" or self.path==None or self.path[:1]==".":
return
if self.path.endswith(".html"):
f = open(curdir + sep + self.path)
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(f.read())
f.close()
return
if self.path.endswith(".mjpeg"):
self.send_response(200)
self.wfile.write("Content-Type: multipart/x-mixed-replace; boundary=--aaboundary")
self.wfile.write("\r\n\r\n")
while 1:
img = cv.QueryFrame(capture)
cv2mat=cv.EncodeImage(".jpeg",img,(cv.CV_IMWRITE_JPEG_QUALITY,cameraQuality))
JpegData=cv2mat.tostring()
self.wfile.write("--aaboundary\r\n")
self.wfile.write("Content-Type: image/jpeg\r\n")
self.wfile.write("Content-length: "+str(len(JpegData))+"\r\n\r\n" )
self.wfile.write(JpegData)
self.wfile.write("\r\n\r\n\r\n")
time.sleep(0.05)
return
if self.path.endswith(".jpeg"):
f = open(curdir + sep + self.path)
self.send_response(200)
self.send_header('Content-type','image/jpeg')
self.end_headers()
self.wfile.write(f.read())
f.close()
return
return
except IOError:
self.send_error(404,'File Not Found: %s' % self.path)
def sendFrame(self, time=None, task=None):
frame = self.panda_camera.getFrameData(time)
frm_time = frame['time']
frm_w = frame['width']
frm_h = frame['height']
image_data = frame['data']
if task:
exp_w = task.width
exp_h = task.height
jpeg = task.jpeg
else:
exp_w = self.image_width
exp_h = self.image_height
jpeg = True
# Resize image if the expected height and width are not met.
if exp_w != frm_w or exp_h != frm_h:
new_image = cv.CreateImage((exp_w, exp_h), cv.IPL_DEPTH_8U, 4)
cv.Resize(image_data, new_image)
else:
new_image = image_data
if jpeg:
new_image = cv.EncodeImage('.jpg', new_image)
image_string = new_image.tostring()
message = eVV_IMG(self.ip, self.port, self.id, exp_w, exp_h,
cv.IPL_DEPTH_8U, BGRA, jpeg, frm_time, image_string)
self.vp.sendMessage(message)
logging.debug(
"Sent VV_IMG message to conn:%s, frame_time: %s, jpeg:%s" %
(self.vp.conn_id, frm_time, jpeg))
def read(self, extension=None, quality=None):
if quality is None:
quality = self.context.config.QUALITY
options = None
extension = extension or self.extension
try:
if FORMATS[extension] == 'JPEG':
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
except KeyError:
# default is JPEG so
options = [cv.CV_IMWRITE_JPEG_QUALITY, quality]
data = cv.EncodeImage(extension, self.image, options or []).tostring()
if FORMATS[
extension] == 'JPEG' and self.context.config.PRESERVE_EXIF_INFO:
if hasattr(self, 'exif'):
img = JpegFile.fromString(data)
img._segments.insert(
0, ExifSegment(self.exif_marker, None, self.exif, 'rw'))
data = img.writeString()
return data
def process(filename):
'''process one file'''
pgm = cuav_util.PGM(filename)
img_full_grey = pgm.array
im_full = numpy.zeros((960, 1280, 3), dtype='uint8')
im_640 = numpy.zeros((480, 640, 3), dtype='uint8')
t0 = time.time()
for i in range(opts.repeat):
scanner.debayer_half(img_full_grey, im_640)
t1 = time.time()
print('debayer: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
for i in range(opts.repeat):
scanner.debayer(img_full_grey, im_full)
t1 = time.time()
print('debayer_full: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
im_full2 = cv.CreateImage((1280, 960), 8, 3)
img_full_grey2 = cv.GetImage(cv.fromarray(img_full_grey))
for i in range(opts.repeat):
cv.CvtColor(img_full_grey2, im_full2, cv.CV_BayerBG2BGR)
t1 = time.time()
print('debayer_cv_full: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
for i in range(opts.repeat):
img = cv.GetImage(cv.fromarray(im_full))
cv.CvtColor(img, img, cv.CV_RGB2HSV)
t1 = time.time()
print('RGB2HSV_full: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
for i in range(opts.repeat):
img = cv.GetImage(cv.fromarray(im_640))
cv.CvtColor(img, img, cv.CV_RGB2HSV)
t1 = time.time()
print('RGB2HSV_640: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
for i in range(opts.repeat):
thumb = numpy.empty((100, 100, 3), dtype='uint8')
scanner.rect_extract(im_full, thumb, 120, 125)
t1 = time.time()
print('rect_extract: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
for i in range(opts.repeat):
thumb = cuav_util.SubImage(cv.GetImage(cv.fromarray(im_full)),
(120, 125, 100, 100))
t1 = time.time()
print('SubImage: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
for i in range(opts.repeat):
scanner.downsample(im_full, im_640)
t1 = time.time()
print('downsample: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
for i in range(opts.repeat):
scanner.scan(im_640)
t1 = time.time()
print('scan: %.1f fps' % (opts.repeat / (t1 - t0)))
t0 = time.time()
for i in range(opts.repeat):
scanner.scan(im_full)
t1 = time.time()
print('scan_full: %.1f fps' % (opts.repeat / (t1 - t0)))
if not hasattr(scanner, 'jpeg_compress'):
return
for quality in [30, 40, 50, 60, 70, 80, 90, 95]:
t0 = time.time()
for i in range(opts.repeat):
jpeg = cPickle.dumps(ImagePacket(
time.time(), scanner.jpeg_compress(im_full, quality)),
protocol=cPickle.HIGHEST_PROTOCOL)
t1 = time.time()
print('jpeg full quality %u: %.1f fps %u bytes' %
(quality, opts.repeat / (t1 - t0), len(bytes(jpeg))))
for quality in [30, 40, 50, 60, 70, 80, 90, 95]:
t0 = time.time()
for i in range(opts.repeat):
img2 = cv.fromarray(im_full)
jpeg = cPickle.dumps(ImagePacket(
time.time(),
cv.EncodeImage(
'.jpeg', img2,
[cv.CV_IMWRITE_JPEG_QUALITY, quality]).tostring()),
protocol=cPickle.HIGHEST_PROTOCOL)
t1 = time.time()
print('EncodeImage full quality %u: %.1f fps %u bytes' %
(quality, opts.repeat / (t1 - t0), len(bytes(jpeg))))
for quality in [30, 40, 50, 60, 70, 80, 90, 95]:
t0 = time.time()
for i in range(opts.repeat):
jpeg = cPickle.dumps(ImagePacket(
time.time(), scanner.jpeg_compress(im_640, quality)),
protocol=cPickle.HIGHEST_PROTOCOL)
t1 = time.time()
print('jpeg 640 quality %u: %.1f fps %u bytes' %
(quality, opts.repeat / (t1 - t0), len(bytes(jpeg))))
for thumb_size in [10, 20, 40, 60, 80, 100]:
thumb = numpy.zeros((thumb_size, thumb_size, 3), dtype='uint8')
t0 = time.time()
for i in range(opts.repeat):
scanner.rect_extract(im_full, thumb, 0, 0)
jpeg = cPickle.dumps(ImagePacket(time.time(),
scanner.jpeg_compress(thumb, 85)),
protocol=cPickle.HIGHEST_PROTOCOL)
t1 = time.time()
print('thumb %u quality 85: %.1f fps %u bytes' %
(thumb_size, opts.repeat / (t1 - t0), len(bytes(jpeg))))
