def test_realImages_instick(self):
return
print("writes in stick")
if not os.path.exists("/media/imgstick"):
return
rmtree("/media/imgstick/a", ignore_errors=True)
time.sleep(1)
saver = ImgSaver("/media/imgstick/")
# source images
realimagesNames = ["moon1.jpg", "moon2.jpg", "mars1.png"]
realimages = [
PIL.Image.open("testimgs/%s" % (_, )) for _ in realimagesNames
]
# resols
srcResols = [(1280, 720), (3296, 2464)]
expcount = 30
res = []
save_formats = ["tiff", "jpg", "bmp"]
for realimgname, realimg in zip(realimagesNames, realimages):
for srcResol in srcResols:
srcimg = resizeImage(realimg, srcResol)
srcimgs = [srcimg for i in range(expcount)]
datesrcs = list(range(expcount))
srcPixCount = srcResol[0] * srcResol[1]
for save_format in save_formats:
for srcimg, dt in zip(srcimgs, datesrcs):
strt = time.time()
saver.save(srcimg, save_format, "a", str(srcPixCount),
dt)
dur = time.time() - strt
res.append([
dur, srcResol, srcPixCount, save_format,
realimgname
])
time.sleep(.2)
cols = ["dur", "srcResol", "srcPixCount", "save_format", "realimgname"]
df = pd.DataFrame(res, columns=cols)
df["pixspeed"] = (df["srcPixCount"] / df["dur"]) / 10**6
df.to_pickle("./save.df")
makeStatpng(df, "realinstick.png", "real_in stick")
rmtree("/media/imgstick/a")
async def bgjob():
"""
use the IMGBUFF global object
"""
global serverConnection
global serverOverwhelmed
log = logging.getLogger("imgForwd")
sleepdur = .1
lastTimingSend = 0
while True:
try:
if len(IMGBUFF.content) > 0:
a, params, triggerDate = IMGBUFF.pop()
save_format = params.get("save_format", "none")
save_section = params.get("save_section", "work")
save_subsection = params.get("save_subsection", "")
if save_format not in ["none"]:
TOSAVEBUFF.stack((a, params, triggerDate))
if not serverOverwhelmed:
log.debug("bgjob with %s objects in buff ",
len(IMGBUFF.content))
log.debug("params : %s", params)
log.debug("will send to server")
if "capture_format" in params and params[
"capture_format"] == "jpeg":
w = params["shootresol"]["width"]
h = params["shootresol"]["height"]
#image = Image.frombytes('RGB', (w,h), a,decoder_name="jpeg")
import io
image = Image.open(io.BytesIO(a))
else:
image = Image.fromarray(a)
if serverConnection:
try:
dispresol = (params["dispresol"]["width"],
params["dispresol"]["height"])
log.debug("go for resize b64 json")
imageDisplay = imgutils.resizeImage(
image, dispresol)
data = imgutils.pilimTobase64Jpg(imageDisplay)
msg = json.dumps({
"usedParams": params,
"msgtype": "srcimage",
"imageData": data
})
log.debug("sending to server")
await serverConnection.send(msg)
await asyncio.sleep(.02) # wait a little
except websockets.exceptions.ConnectionClosed as e:
serverConnection = False
log.error("disconnected with server %s", e)
except Exception as e:
log.exception("err sending to server %s", e)
else:
log.info("no server")
else:
log.debug("server has too much work")
await asyncio.sleep(.001)
else:
# wait for image
await asyncio.sleep(sleepdur)
if time.time() > lastTimingSend + 3:
lastTimingSend = time.time()
# now send timing data
timingData = {
"imgbuffcount": len(IMGBUFF.content),
"tosavecount": len(TOSAVEBUFF.content),
}
#msg = ",".join(["%s: %.2f"%(k,timingData[k]) for k in sorted(timingData.keys()) if "dur" in k])
log.info("some info %s ", timingData)
if serverConnection:
msg = makeMessage("camTiming", timingData, jdump=True)
await serverConnection.send(msg)
await asyncio.sleep(.0001)
except concurrent.futures._base.CancelledError as e:
log.info("quit due to cancelledError")
return
except KeyboardInterrupt as e:
log.info("quit due to key interrupt")
return
except Exception as e:
log.exception("error")
def test_1(self):
"""
ls:[ {name:"128x64", width:128,height:64},
{name:"480x368", width:480,height:368},
{name:"640x480", width:640,height:480},
{name:"1280x720", width:1024,height:720},
{name:"1640x1232", width:1640,height:1232},
{name:"1920x1080", width:1920,height:1080},
{name:"1920x1088", width:1920,height:1088},
{name:"3280x2464", width:3280,height:2464},
{name:"3296x2464", width:3296,height:2464},
],
"""
#srcResol = (3296,2464)
#targtResol = (1280,720)
srcResol = (3296, 2464)
targtResol = (480, 368)
srcPixCount = srcResol[0] * srcResol[1]
trgPixCount = targtResol[0] * targtResol[1]
rgap = None
expcount = 10
mods = [["NEAREST", PIL.Image.NEAREST], ["BICUBIC", PIL.Image.BICUBIC]]
rgaps = [None, 1.0, 2.0, 3.0]
res = []
srcimgs = [makePilIMgs(resol=srcResol) for i in range(expcount)]
for modestr, mod in mods:
for rgap in rgaps:
for srcimg in srcimgs:
strt = time.time()
newimgs = resizeImage(srcimg,
targtResol,
mod,
reducing_gap=None)
dur = time.time() - strt
res.append([
dur, srcResol, targtResol, srcPixCount, trgPixCount,
rgap, modestr
])
cols = [
"dur", "srcResol", "targtResol", "srcPixCount", "trgPixCount",
"rgap", "modestr"
]
df = pd.DataFrame(res, columns=cols)
df["pixspeed"] = (df["srcPixCount"] / df["dur"]) / 10**6
df.to_pickle("./save.df")
makeStatpng(df,
"resizeSpd.png",
"resize Speed",
testedCols=["rgap", "modestr"])
async def cameraLoop():
global continueLoop
global freshParams
await asyncio.sleep(1)
while True:
try:
log = logging.getLogger("cameraLoop")
params = cleanParams(freshParams)
shootresol = params["shootresol"]
strtResolution = (shootresol["width"], shootresol["height"])
log.info("OpeningCamera at resol %s", (strtResolution, ))
with PiCamera(resolution=strtResolution,
framerate_range=(0.1, 30)) as camera:
log.info("got camera")
continueLoop = True
while continueLoop:
params = cleanParams(freshParams)
shootresol = params["shootresol"]
dispresol = (params["dispresol"]["width"],
params["dispresol"]["height"])
if (shootresol["width"] != strtResolution[0]):
log.info("resolution changed!")
break
log.info("looping %s", params)
capture_format = params["capture_format"]
# setting camera config
camsetting_start = time.time()
camera.iso = params["isovalue"]
camera.brightness = params["brightness"]
camera.contrast = params["contrast"]
# camera.analog_gain=1.0
camera.exposure_mode = params["expomode"]
camera.exposure_compensation = params[
"exposure_compensation"]
camera.saturation = params["saturation"]
camera.shutter_speed = params["shutterSpeed"]
log.info("setting awb_mode off")
camera.awb_mode = 'off'
g = (params["redgain"], params["bluegain"])
camera.awb_gains = g
camsetting_dur = time.time() - camsetting_start
log.info("create databuff")
if (capture_format in ["yuv"]):
stream = open("/dev/shm/lol.data", "w+b")
else:
stream = BytesIO()
log.info("capture start capture_format:%s", capture_format)
triggerDate = time.time()
camera.capture(stream,
format=capture_format,
use_video_port=False)
capture_dur = time.time() - triggerDate
# into pill
log.info("reading image")
strtTime = time.time()
if (capture_format == "jpeg"):
stream.seek(0)
image = Image.open(stream)
elif (capture_format == "yuv"):
stream.seek(0)
rgb = imgutils.yuvbytesToRgb(stream, *strtResolution)
image = Image.fromarray(rgb)
elif (capture_format == "rgb"):
stream.seek(0)
image = Image.frombytes("RGB", strtResolution,
stream.getvalue(), "raw",
"RGB", 0, 1)
#image = Image.frombuffer("RGB",strtResolution,stream,"raw","RGB",0,1)
pil_dur = time.time() - strtTime
#log.info(image.size)
strtTime = time.time()
#histData = imgutils.colorHist(image)
hist_dur = time.time() - strtTime
log.info("resizing")
strtTime = time.time()
imageDisplay = imgutils.resizeImage(image, dispresol)
resize_dur = time.time() - strtTime
# save original image
strtTime = time.time()
save_format = params["save_format"]
save_section = params["save_section"]
save_subsection = params["save_subsection"]
if save_format in [
"none",
]:
pass
else:
IMGBUFF.stack((image, save_format, save_section,
save_subsection, triggerDate))
save_dur = time.time() - strtTime
# publish image to server
usedParams = {
"triggerDate": triggerDate,
"gains": [float(_) for _ in camera.awb_gains],
"analog_gain": float(camera.analog_gain),
"iso": camera.iso,
"brightness": camera.brightness,
"saturation": camera.saturation,
"contrast": camera.contrast,
"exposure_compensation": camera.exposure_compensation,
"resolution": list(strtResolution),
"imageSize": image.size,
"shutterSpeed": camera.shutter_speed,
"exposure_speed": camera.exposure_speed,
"exposure_mode": camera.exposure_mode,
"awb_mode": camera.awb_mode,
"capture_format": capture_format,
"save_format": save_format,
"save_section": save_section,
"camsetting_dur": camsetting_dur,
"capture_dur": capture_dur,
"pil_dur": pil_dur,
"hist_dur": hist_dur,
"resize_dur": resize_dur,
"save_dur": save_dur,
}
strtTime = time.time()
if serverConnection:
try:
data = imgutils.pilimTobase64Jpg(imageDisplay)
msg = json.dumps({
"usedParams": usedParams,
"msgtype": "srcimage",
"imageData": data
})
await serverConnection.send(msg)
except Exception as e:
log.exception("err %s", e)
else:
log.info("no server")
# end sending
send_dur = time.time() - strtTime
# now send timing data
timingData = {
"triggerDate": triggerDate,
"imgbuffcount": len(IMGBUFF.content),
"send_dur": send_dur,
"usedParams": usedParams
}
msg = ",".join([
"%s: %.2f" % (k, timingData[k])
for k in sorted(timingData.keys()) if "dur" in k
])
log.info("timing info %s , %s in buff", msg,
len(IMGBUFF.content))
if serverConnection:
msg = makeMessage("camTiming", timingData, jdump=True)
await serverConnection.send(msg)
await asyncio.sleep(.0001)
# end while
log.info("ending capture loop, camera will be reopened")
#end with camera
#no camera here
log.info("camera closed")
except Exception as e:
log.exception("whooops")
await asyncio.sleep(1)