def _write_results_on_machine(image, eggs, clusters, imname):
rpath = get_root(__file__)[:get_root(__file__).index('/')]
for egg in eggs:
egg = detect.get_egg_border(egg, image.shape[:2])
image[egg[:, 0], egg[:, 1]] = (0, 0, 255)
for cluster in clusters:#range(len(clusters)):
cluster = detect.get_egg_border(cluster, image.shape[:2])
image[cluster[:, 0], cluster[:, 1]] = (0, 255, 0)
cv2.imwrite(rpath + imname[:-4] + "_TEST.jpg", image)
def runDet(diaPath):
import os
import sys
import optparse
import lsst.daf.data as dafBase
import lsst.pex.policy
import lsst.pex.logging
import lsst.afw.image as afwImage
import lsst.afw.detection as afwDet
import lsst.detection as det
import Detection
defInDir = os.environ.get("FWDATA_DIR", "")
moduleDir = os.path.split(__file__)[0]
appDir = os.path.normpath(os.path.join("../../../",moduleDir))
defDiaPath = os.path.join(defInDir, "871034p_1_MI")
defPolicyPath = os.path.join(appDir, "pipeline/DetectionStagePolicy.paf")
defVerbosity = 5 # change to 0 once this all works to hide all messages
policyPath = defPolicyPath
diaExposure = afwImage.ExposureF()
diaExposure.readFits(diaPath)
diaMaskedImage = diaExposure.getMaskedImage()
diaWCS = diaExposure.getWcs()
policy = lsst.pex.policy.Policy.createPolicy(policyPath)
diaSources = Detection.detection(diaExposure, policy)
for i in range(len(diaSources)):
diaSource_i = diaSources[i]
print diaSource_i.toString()
def main():
classification = Classification.Classifier() #Classification part
classification.do_knn()
classification.do_svm()
classification.do_random_forest()
classification.do_neural_network()
detection = Detection.Detector() #sliding window and classification
detection.run()
def process(self):
logging.Trace_setVerbosity("lsst.detection", 5)
logging.Trace(
"lsst.detection.DetectionStage", 3,
'Python DetectionStage process : _rank %i stageId %d' %
(self._rank, self.stageId))
activeClipboard = self.inputQueue.getNextDataset()
###########
#
# Get objects from clipboard
#
triggerEvent = activeClipboard.get('triggerVisitEvent')
filterNameItem = triggerEvent.findUnique('filterName')
filterName = filterNameItem.getValueString()
exposureIdItem = triggerEvent.findUnique('exposureId')
exposureId = exposureIdItem.getValueInt()
visitTimeItem = triggerEvent.findUnique('visitTime')
visitTime = visitTimeItem.getValueDouble()
###########
#
# Log the beginning of Detection stage for this slice
#
LogRec(self.detectionLog, Log.INFO) \
<< "Began detection stage" \
<< DataProperty("exposureId", exposureId) \
<< DataProperty("visitTime", visitTime) \
<< DataProperty("filterName", filterName) \
<< LogRec.endr
#
# Instantiate a Filter object to get the id of filterName
#
dbLocation = dafper.LogicalLocation(
'mysql://lsst10.ncsa.uiuc.edu:3306/test')
filterDB = lsst.afw.image.Filter(dbLocation, filterName)
filterId = filterDB.getId()
logging.Trace("lsst.detection.DetectionStage", 3,
'FilterName %s FilterId %d' % (filterName, filterId))
differenceImageExposure = activeClipboard.get('DifferenceExposure')
diaSourceCollection = Detection.detection(
differenceImageExposure=differenceImageExposure,
policy=self._policy,
filterId=filterId,
useLog=self.detectionLog,
footprintList=None,
)
###########
#
# Post results to clipboard
#
activeClipboard.put('DiaSources', diaSourceCollection)
self.outputQueue.addDataset(activeClipboard)
def main(argv):
SHOW_FRAME = True
WRITE_FRAME = True
start_webserver("0.0.0.0", 5000)
dt = Detection.Recog()
sync = SimpleSynchronise(10, 3)
cam = Cam.URLCam("http://192.168.188.200:200/cam1/cam_pic.php")
#cam = Cam.WebCam(0)
if SHOW_FRAME:
cv.namedWindow("canvas")
display = [Display((900, 1440))] * 9
renderer = MultiScreenFaceDisplay(display)
overlay = OverlayScreenFaceDisplay()
while True:
frame = cam.read_image()
if frame is None:
continue
frame = cv.resize(frame, (1440, 900))
faces = dt.detectFaces(frame)
faces = list(faces)
print(faces)
loaded = list(load_faces(frame, faces))
overlay.clear()
renderer.clear()
overlay.add_face(loaded)
renderer.add_face(loaded)
img = overlay.render(frame)
images = renderer.render(frame)
if SHOW_FRAME:
#img2 = cv.resize(img, (1440, 900))
cv.imshow("canvas", img)
if cv.waitKey(1) == ord('q'):
break
if sync.check_sync():
if WRITE_FRAME:
cv.imwrite("img/over.jpg",
img) #write overlay to special filename
i = 1
for image in images:
cv.imwrite("img/{:>05}.jpg".format(i),
image) #write images to file
i += 1
def encryptProfile(Str):
Encoded = profile_for(Str)
Blocks = Padding.pad(Encoded, 16)
plainText = ""
for Block in Blocks:
plainText += Block
Key = Detection.randKey()
cipher = AES.AESCipher(Key, AES.MODE_ECB)
CipherText = cipher.encrypt(plainText)
return CipherText, Key
def encryptProfile(Str):
Encoded = profile_for(Str)
Blocks = Padding.pad(Encoded, 16)
plainText = ""
for Block in Blocks:
plainText += Block
Key = Detection.randKey()
cipher = AES.AESCipher(Key,AES.MODE_ECB)
CipherText = cipher.encrypt(plainText)
return CipherText, Key
def main():
cprint('+-------------------------------+', 'yellow')
cprint('| |', 'yellow')
cprint('| Welcome, ZJUer! |', 'yellow')
cprint('| |', 'yellow')
cprint('| Auto Login ZJUWLAN (v1) |', 'yellow')
cprint('| create by ChanLo |', 'yellow')
cprint('| |', 'yellow')
cprint('+-------------------------------+\n', 'yellow')
UPSave = DataSave.UPSave()
if not if_use_existing_account(use_account):
username, password = get_user_UP()
UPSave.delete_DB(name_DB)
UPSave.create_DB(name_DB)
UPSave.insert_to_DB(name_DB, username, password)
else:
username, password = UPSave.select_DB(name_DB, aim_id)
data = {
'action': 'login',
'username': username,
'password': password,
'ac_id': '3',
'user_ip': '',
'nas_ip': '',
'user_mac': '',
'save_me': '1',
'ajax': '1'
}
data = urllib.parse.urlencode(data)
try:
req = Request('https://net.zju.edu.cn/srun_portal_pc.php?url=&ac_id=3')
with urlopen(req, data.encode('utf-8'), timeout=10) as response:
content = response.read()
cprint('Checking network status...\n', 'green')
sleep(1)
detection = Detection.Detection()
if detection.is_connected():
cprint('Login Successfully!', 'red')
else:
cprint('Connection fail.', 'green')
except URLError as e:
if hasattr(e, 'reason'):
info = '[ERROR] Failed to reach the server.\Reason: ' + str(
e.reason)
elif hasattr(e, 'code'):
info = '[ERROR] The server couldn\'t fullfill the request.\nError code: ' + str(
e.reason)
else:
info = '[ERROR] Unknown URLError'
print(info)
except:
import traceback
print('Generic exception: ' + traceback.format_exc())
def process(self):
logging.Trace_setVerbosity("lsst.detection", 5)
logging.Trace("lsst.detection.DetectionStage", 3, 'Python DetectionStage process : _rank %i stageId %d' % (self._rank, self.stageId))
activeClipboard = self.inputQueue.getNextDataset()
###########
#
# Get objects from clipboard
#
triggerEvent = activeClipboard.get('triggerVisitEvent')
filterNameItem = triggerEvent.findUnique('filterName')
filterName = filterNameItem.getValueString()
exposureIdItem = triggerEvent.findUnique('exposureId')
exposureId = exposureIdItem.getValueInt()
visitTimeItem = triggerEvent.findUnique('visitTime')
visitTime = visitTimeItem.getValueDouble()
###########
#
# Log the beginning of Detection stage for this slice
#
LogRec(self.detectionLog, Log.INFO) \
<< "Began detection stage" \
<< DataProperty("exposureId", exposureId) \
<< DataProperty("visitTime", visitTime) \
<< DataProperty("filterName", filterName) \
<< LogRec.endr
#
# Instantiate a Filter object to get the id of filterName
#
dbLocation = dafper.LogicalLocation('mysql://lsst10.ncsa.uiuc.edu:3306/test')
filterDB = lsst.afw.image.Filter(dbLocation, filterName)
filterId = filterDB.getId()
logging.Trace("lsst.detection.DetectionStage", 3, 'FilterName %s FilterId %d' % (filterName, filterId))
differenceImageExposure = activeClipboard.get('DifferenceExposure')
diaSourceCollection = Detection.detection(
differenceImageExposure = differenceImageExposure,
policy = self._policy,
filterId = filterId,
useLog = self.detectionLog,
footprintList = None,
)
###########
#
# Post results to clipboard
#
activeClipboard.put('DiaSources', diaSourceCollection)
self.outputQueue.addDataset(activeClipboard)
def __process_det_file(self, det_file=''):
"""
Defines what information to gather when processing each detection file.
This shouldn't be called directly.
Change anything in here as it will change what information it will gather from each file.
"""
file_text = open(det_file, 'r')
lines = file_text.readlines()
file_text.close()
result = []
for line in lines:
aux = [float(val) for val in line.rstrip('\n').split(',')]
result.append(aux)
for i, det in enumerate(result):
if len(det) > 5:
detection = Detection(det[0], det[1], det[2], det[3], det[4], det[5], det[6:])
result[i] = detection.return_dict()
else:
detection = Detection(det[0], det[1], det[2], det[3], det[4], 0, [])
result[i] = detection.return_dict()
return result
def process_image(img):
img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
mydetect = Detection.Detection(img, picklefile)
mydetect.multiple_scale_window(scales, y_start_stops)
#print(Record.history_track)
if len(Record.history_track) > 0:
last_threshold = mydetect.process_heatmap(np.int(np.min(np.array(Record.history_track))))
else:
last_threshold = mydetect.process_heatmap(2)
if last_threshold > 0:
Record.history_track.append(last_threshold)
else:
Record.history_track = []
if len(Record.history_track) > Record.cache_size:
Record.history_track = Record.history_track[1:]
return mydetect.draw_label_box()
def detect():
if request.method == 'POST' and request.files['image']:
img = request.files['image']
img_name = img.filename
create_new_folder(app.config['SRC_FOLDER'])
create_new_folder(app.config['DEST_FOLDER'])
saved_path = os.path.join(app.config['SRC_FOLDER'], img_name)
saved_path1 = os.path.join(app.config['DEST_FOLDER'], img_name)
app.logger.info("saving {}".format(saved_path))
img.save(saved_path)
img.save(saved_path1)
detections = Detection.detectObject(saved_path, saved_path1)
strings2 = list()
for eachObject in detections:
strings2.append(
eachObject["name"] + " : " +
"{:10.2f}".format(eachObject["percentage_probability"]))
return render_template('detect.html',
sourceImage=img_name,
newImage=img_name,
data=strings2)
else:
return "Where is the image?"
)
orimg = cv2.imread(sys.argv[1], 0) # Read the imag
height, width = orimg.shape[0:2]
img_resized = cv2.resize(orimg, (1300, int(1300 * (height / width))))
img = img_resized[:]
print(
"................................Image Loading................................"
)
print("DONE")
box_list = list()
print(
"...............................Detecting Images............................."
)
box_list, page_width = Detection.ImageDetect(img, box_list)
print("DONE")
for i in box_list:
img[i.y1:i.y2, i.x1:i.x2] = np.ones((i.y2 - i.y1, i.x2 - i.x1)) * 255
print(
".................................Detecting Text.............................."
)
box_list = Detection.TextDetect(img, box_list)
print("DONE")
#for i in range(len(box_list)-1):
# if(box_list[i].text==""):
# del box_list[i]
def recast(self, delrec, geff, optype, useHeavyMeson=False):
# we define the recast based on the expected signal
if self.channel == "decay":
if self.model == "EFT": # For naive NoE based limits
xi, EffLimtmp = de.GetNaiveDecayLimits(delrec, self.exp, 10,
geff, optype)
xi, EffLim, EffLim_low = de.RecastDecayLimit(
xi, EffLimtmp, delrec, delrec, self.exp, geff, optype)
xi_full, Lim_full = uf.CombineUpDown(xi, EffLim_low, EffLim,
self.combthr)
else: # Standard recasting case
xi_full, Lim_full = de.FastDecayLimit(
self.exp, self.mx_ini, self.lim_ini, self.delini, delrec,
geff, optype, self.combthr, useHeavyMeson)
elif self.channel == "heavymesondecay":
if self.model == "EFT":
xi, EffLimtmp = de.GetNaiveDecayLimits(delrec, self.exp, 10,
geff, optype, True)
xi_heavy, EffLim_heavy, EffLim_heavy_low = de.RecastDecayLimit(
xi, EffLimtmp, delrec, delrec, self.exp, geff, optype,
True)
xi_full, Lim_full = uf.CombineUpDown(xi_heavy,
EffLim_heavy_low,
EffLim_heavy,
self.combthr)
else:
xi_full, Lim_full = de.FastDecayLimit(
self.exp, self.mx_ini, self.lim_ini, self.delini, delrec,
geff, optype, self.combthr, useHeavyMeson)
elif self.channel == "scattering":
xi_full, Lim_full = de.FastScatLimit(self.exp, self.mx_ini,
self.lim_ini, self.delini,
delrec, geff, optype)
elif self.channel == "monogam":
xi_full, Lim_full = de.FastMonoPhoton(self.exp, self.mx_ini,
self.lim_ini, self.delini,
delrec, geff, optype)
elif self.channel == "invisibledecayBmtoKm":
if self.exp == "babar":
xi_full, Lim_full = de.FastInvMesDecay("babar_BmtoKmnunu",
delrec, geff, optype)
elif self.exp == "belle2":
xi_full, Lim_full = de.FastInvMesDecay("belle2_BmtoKmnunu",
delrec, geff, optype)
elif self.channel == "invisibledecayBmtoPim":
xi_full, Lim_full = de.FastInvMesDecay("babar_BmtoPimnunu", delrec,
geff, optype)
elif self.channel == "invisibledecayB0toPi0":
xi_full, Lim_full = de.FastInvMesDecay("belle_B0toPi0nunu", delrec,
geff, optype)
elif self.channel == "invisibledecayB0toK0":
xi_full, Lim_full = de.FastInvMesDecay("belle_B0toK0nunu", delrec,
geff, optype)
elif self.channel == "monojet_down":
xi_full, Lim_full = de.FastMonoJet(self.exp, self.mx_ini,
self.lim_ini, self.delini,
delrec, geff, optype)
elif self.channel == "monojet_up":
xi_full, Lim_full = de.FastMonoJet(self.exp, self.mx_ini,
self.lim_ini, self.delini,
delrec, geff, optype)
elif self.channel == "invisibledecayKL0toPi0":
if self.exp == "e391a":
xi_full, Lim_full = de.FastInvMesDecay("e391a_KL0toPi0nunu",
delrec, geff, optype)
if self.exp == "na62":
xi_full, Lim_full = de.FastInvMesDecay("na62_KL0toPi0nunu",
delrec, geff, optype)
elif self.channel == "invisibledecayPi0":
xi_full, Lim_full = de.FastInvMesDecay("na62_pi0toinvisible",
delrec, geff, optype)
elif self.channel == "invisibledecayJPsi":
xi_full, Lim_full = de.FastInvMesDecay("bes_JPsitoinvisible",
delrec, geff, optype)
elif self.channel == "invisibledecayUpsilon":
xi_full, Lim_full = de.FastInvMesDecay("babar_Upsilontoinvisible",
delrec, geff, optype)
elif self.channel == "invisibledecayKptoPip":
if self.exp == "na62":
xi_full, Lim_full = de.FastInvMesDecay("na62_KptoPipa", delrec,
geff, optype)
elif self.exp == "e949":
xi_full, Lim_full = de.FastInvMesDecay("e949_KptoPipa", delrec,
geff, optype)
elif self.channel == "cosmicrays":
xi_full, Lim_low_full, Lim_high_full = de.FastCRLimit(
"t2k", delrec, geff, optype)
xi_full, Lim_full = uf.CombineUpDown(xi_full, Lim_low_full,
Lim_high_full)
elif self.channel == "low_cooling":
xi_full, Lim_full = de.FastSN1987Limit(self.lim_inifull, delrec,
geff, optype, False)
elif self.channel == "high_cooling":
xi_full, Lim_full = de.FastSN1987Limit(self.lim_inifull, delrec,
geff, optype, True)
else:
print(
"Channel selected: ", self.channel,
" is not currently implemented. Possible choices: \n",
"'decay' : faser, mathusla, ship, charm, seaquest, seaquest_Phase2, lsnd \n",
"heavymesondecay : ship"
"'scattering' : nova, miniboone, sbnd \n",
"'missingE' : babar, belleII, atlas, lep \n",
"'cosmicrays' : t2k (decay from cosmic ray showers into t2k), ",
"cooling : for sn1987_low (pessimistic limit from SN1987 cooling), sn1987_high (optimistic limit from SN1987 cooling) ",
"Invisible light meson decays: na62 (pi0decay and invisibledecayKptoPip) e949 (pi0decay and invisibledecayKptoPip), e391a (invisibledecayKL0toPi0)",
"Invisible heavy meson decay: belle (invisibledecayB0toPi0 ,invisibledecayB0toK0) and belleII (invisibledecayBmtoKm)"
)
xi_full = np.logspace(-3., 1., 30.)
Lim_full = np.zeros(np.shape(xi_full))
return xi_full, Lim_full
exit()
# The first step is to check if the image really has a pallete with a circle at its center.
im = Defects.hasPalette(im)
if type(im) == type(""):
exit()
print("Detecting circle...")
# detecting the central circle
# The program will try to recognize the central circle in 30 attempts.
# In case the circle isn't yet recognized, we flip the image in 180 degrees.
# Through the radius of the circle we can estimate the size of the eggs.
params = None
for att in range(30):
params = detect.detect_circle_mark(im)
if type(params) == type(None):
if att == 29:
for i in range(2):
im = cv2.transpose(im)
im = cv2.flip(im, 1)
params = detect.detect_circle_mark(im)
if type(params) == type(None):
print(IO.json_packing_error('ERR_003'))
exit()
else:
break
count = 1
while count < 45 or cv2.waitKey == 13:
(_, im) = webcam.genNextFrame()
#time.sleep(0.38)
cv2.imshow('OpenCV', im)
count += 1
im = cv2.flip(im, 1, 0)
det.setScaleFactor(1.3)
det.setMinNeighbours(5)
gray = det.gray(im)
faces = det.detect(gray)
print(len(faces))
detection = Detection.Detection2D(scene=im)
for (x, y, w, h) in faces:
detection.drawBoundingBox(x, y, w, h, 2, (255, 0, 0))
#cv2.rectangle(im,(x,y),(x+w,y+h),(255,0,0),2)
face = gray[y:y + h, x:x + w]
detection.drawBoundingBox(x, y, w, h, 3, (0, 255, 0))
#cv2.rectangle(im, (x, y), (x + w, y + h), (0, 255, 0), 3)
pred, l, conf = rec.predict(face, im_width, im_height)
print(pred, conf)
#print (&quot;pred&quot;,prediction)
if conf < 75:
#cv2.putText(im,'%s - %.0f' % (names[pred],pred),(x-10, y-10), cv2.FONT_HERSHEY_PLAIN,1,(0, 255, 0))
detection.putText(text="%s - %.0f" % (names[pred], conf),
font=cv2.FONT_HERSHEY_PLAIN,
color=(0, 255, 0))
Str = "comment1=cooking%20MCs;userdata=" + UserData + ";comment2=%20like%20a%20pound%20of%20bacon"
Blocks = Padding.pad(Str, 16)
PlainText = ""
for Block in Blocks:
PlainText += Block
return CBCEncrypt(PlainText, Key, IV)
def DecryptData(CipherText, Key, IV):
PlainText = CBCDecrypt(CipherText, Key, IV)
if ";admin=true;" in PlainText:
return True
return False
Key = Detection.randKey()
IV = Detection.randKey()
Message = "Hello World My Name is Max Check"
List = []
for byte in Message:
List.append(ord(byte))
print List[:16], "\t", List[16:]
cipherText = CBCEncrypt(Message, Key, IV)
byteList = []
for byte in cipherText:
byteList.append(ord(byte))
print byteList[:16], "\t", byteList[16:]
byteList[0] = byteList[0] ^ 97 ^ 5
cipherText = ""
print "Error"
return None
def findAll(Message, Key, blockSize, Rand):
Chars = []
for i in range(len(Message)):
if i % blockSize == 0:
newMessage = Message[i:]
cipherText = ECB_Encrypt(newMessage, Key, "A" * offset + "A" * ((blockSize - (i % blockSize) - 1)),Rand)
knownStr = "A" * offset + "A" * (blockSize - (i % blockSize) - 1)
for j in range(i % blockSize):
knownStr += Chars[j + (i / blockSize) * blockSize]
print knownStr
Chars.append(findByte(cipherText, knownStr, Key, Rand))
print Chars
return Chars
Key = Detection.randKey()
Randnum = random.randint(5,10)
Rand = os.urandom(Randnum)
Message = ""
file = open("ECBText","r")
for line in file:
Message += line.strip("\n")
file.close()
Message = binascii.a2b_base64(Message)
blockSize, offset = BlockAndOffset(Message, Key, Rand)
print blockSize, offset
findAll(Message, Key, blockSize, Rand)
x = indices[1][i] - centerSmall[0]
y = centerSmall[1] - indices[0][i]
rho = np.sqrt(x**2 + y**2)
theta = (np.arctan2(y, x))
if theta < 0:
theta = theta + 2 * np.pi
points.append((rho, theta))
plt.scatter([point[1] for point in points], [point[0] for point in points],
s=0.2)
plt.show()
# Ignoring the distorted (?) regions.
points_truncated = [
point for point in points if 2 <= point[1] <= 4.5 and point[0] > 3105
]
#plt.scatter([point[1] for point in points_truncated], [point[0] for point in points_truncated], s=0.2)
#plt.show()
h, bin_edges = Detection.points_histogram(
[point[0] for point in points_truncated])
#plt.hist([point[0] for point in points_truncated], bin_edges)
#plt.show()
# To do: the inclusion threshold would be a good thing to expose to the user
grooves = Detection.points_to_grooves(h, bin_edges, 1000, points_truncated)
for groove in grooves:
plt.scatter(groove.get_theta_axis(), groove.get_rho_axis(), s=0.2)
plt.show()
feature_params = dict(maxCorners=500,
qualityLevel=0.3,
minDistance=7,
blockSize=7)
# Parameters for lucas kanade optical flow
lk_params = dict(winSize=(15, 15),
maxLevel=2,
criteria=(cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10,
0.03))
kernel = np.ones((7, 7), np.uint8) #erosion kernel
smoothing_kernel = np.ones((25, 25), np.float32) / 25 #smoothing kernel
#detect a base skin color
skin_base = Detection.skin_detect(cap)
if skin_base.size != 0:
#skin color range
skin_lower = np.array([skin_base[0] - 20, 50, 50])
skin_upper = np.array([skin_base[0] + 20, 255, 255])
# Find corners of first frame
ret, frame = cap.read()
frame = cv2.flip(frame, 1)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#set the length of motion necessary to perform action
height, width, channels = frame.shape
motion_length = width / 4
def main():
#parse command line arguments
parser = argparse.ArgumentParser(description='Initialize autoturret.')
parser.add_argument('target_class',
type=str,
help='Pick a target class from the list')
#parser.add_argument('pin_file', type=str, help='file path to file containing pin info')
parser.add_argument(
'--fire',
action='store_true',
default=False,
help='just track target instead of automatically firing',
dest='fire')
parser.add_argument('--showStream',
action='store_true',
default=False,
help="if you want to see it work.q")
results = parser.parse_args()
USER_TARGET = results.target_class
PIN_FILEPATH = 'pin_loc.txt' #results.pin_file
FIRE = results.fire
SHOW_STREAM = results.showStream
ACTIVE = True
#import from file global constant pin locations
pin_dict = Utils.parse_pinfile(PIN_FILEPATH)
#initialize drivers
print('Initializing Drivers....')
m1 = Drivers.Motor1(pin_dict['M1A1'], pin_dict['M1A2'], pin_dict['M1B1'],
pin_dict['M1B2'])
m2 = Drivers.Motor2(enable=pin_dict['en2'],
direction=pin_dict['dirpin2'],
pulse=pin_dict['pul2'])
launcher = Drivers.Launcher(pin_dict['WaterPin'], pin_dict['AirPin'], 1,
.4)
#initialize interface
print("Setting up interface...")
control = Interface.CannonControl(m1, m2, launcher)
# import the correct version of tensorflow based on whats installed and define and interpreter
# from on the .tflite file
if importlib.util.find_spec('tflite_runtime'):
import tflite_runtime.interpreter as tflite
interpreter = tflite.Interpreter(model_path='model/detect.tflite')
else:
import tensorflow as tf
interpreter = tf.lite.Interpreter(model_path='model/detect.tflite')
interpreter.allocate_tensors()
#load labels
with open('model/labelmap.txt', 'r') as f:
labels = [line.strip() for line in f.readlines()]
#initialize detection model
print("Starting detection model...")
model = Detection.TargetStream(USER_TARGET, interpreter)
model.start()
time.sleep(2)
print("Model ready...")
#define autotarget functionality
#toss that in a loop. consiter using threads
while ACTIVE:
if SHOW_STREAM:
model.show_frame()
if model.object_detected:
location = model.target_location
h, v, dist = Utils.auto_target((location))
Utils.move(h, v, dist, control, 3)
time.sleep(1)
def getArg(ind, defValue):
if ind < len(args):
return args[ind]
return defValue
diaPath = getArg(0, defDiaPath)
policyPath = getArg(1, defPolicyPath)
diaExposure = afwImage.ExposureF()
diaExposure.readFits(diaPath)
diaMaskedImage = diaExposure.getMaskedImage()
diaWCS = diaExposure.getWcs()
policy = lsst.pex.policy.Policy.createPolicy(policyPath)
if options.debugIO:
policy.set("debugIO", True)
if options.verbosity > 0:
print "Verbosity =", options.verbosity
lsst.pex.logging.Trace_setVerbosity("lsst.detection", 9)
diaSources = Detection.detection(diaExposure, policy, 0)
for i in range(len(diaSources)):
diaSource_i = diaSources[i]
print diaSource_i.getColc(), " ", diaSource_i.getRowc(
), " -> ", diaSource_i.getRa(), " ", diaSource_i.getDec()
)
res = trainTicket.trainTicket(result)
res = res.res
res = [{'text': res[key], 'name': key, 'box': {}} for key in res]
return res
if __name__ == '__main__':
# threaded=False, processes=3
runAngel = False
path_model = r"./models/invoice_VAT.pb"
path_craft_model = r"./models/weight.pb"
path_direct_model = r""
if (runAngel == True):
path_direct_model = r"Angle-model.pb"
else:
path_direct_model = None
path_pbtxt = r"./labels_pbtxt/invoiceDetection.pbtxt" # 载入标签文件
NUM_CLASSES = 35 # 分类数量
Detection = detect.invoiceDetection(path_model, path_craft_model,
path_pbtxt, NUM_CLASSES,
path_direct_model) # 构建预测类
path_craft_model = r".、weight.pb"
Detection_qdb = detect_qdb.Detection_craft(path_craft_model)
app.run(host='0.0.0.0', port=7799, threaded=True)
class CellFocusAuxillary(ZStackData):
"""
Collects images at different focal planes of the cell.
Records position of the xy, objective_height, img_folder into a pandas dataframe (exported to csv).
Images are organized into folders based off of the time_data of acquisition.
"""
_focus_dir = os.getcwd() + "\\focus_data"
_temp_file = _focus_dir + "\\cell_data.csv"
file_prefix = "Cell"
def get_images(fc, im):
while True:
fc.quickcheck()
time.sleep(1.5)
im.start_acquisition()
if __name__ == "__main__":
CENTER = [3730, -1957]
hd = CESystems.NikonEclipseTi()
hd.start_system()
det = Detection.CellDetector(hd)
mov = Detection.Mover(CENTER)
fc = Detection.FocusGetter(det, mov)
def sniffSlaac(self, buf, getInterface):
eth = EthDecoder().decode(buf)
ethChild = eth.child()
ethChild2 = ethChild.child()
try:
if ethChild2.get_ip_protocol_number() == 58:
destination_MAC_address = eth.get_ether_dhost()
source_MAC_address = eth.get_ether_shost()
source_MAC_address_final = ""
destination_MAC_address_final = ""
override_flag = False
router_flag = False
router_lifetime = "False"
for x in range(6):
temp_decimal = source_MAC_address[x]
temp_hex = hex(temp_decimal)
source_MAC_address_final = source_MAC_address_final + temp_hex[
2:] + ":"
temp_decimal = destination_MAC_address[x]
temp_hex = hex(temp_decimal)
destination_MAC_address_final = destination_MAC_address_final + temp_hex[
2:] + ":"
source_MAC_address_final = source_MAC_address_final[:-1].zfill(
2)
destination_MAC_address_final = destination_MAC_address_final[:
-1]
target_link_layer_address = ""
packetData = (ethChild2.get_originating_packet_data())
packetHex = []
payloadHex = []
for data in packetData:
packetHex.append(hex(data))
source_link_layer_address = ""
target_address = ""
ip_source_address = ethChild.get_source_address()
ip_destination_address = ethChild.get_destination_address()
ndp_message_number = ethChild2.get_type()
contains_source, offset = self.check_ipv6_options(packetHex)
if str(ndp_message_number) == "134": #Router Advertisement
if str(contains_source) == "true-source":
for x in range(6):
source_link_layer_address = source_link_layer_address + packetHex[
x + offset + 1][2:].zfill(2) + ":"
target_address = "n/a"
source_link_layer_address = source_link_layer_address[:
-1]
target_link_layer_address = "n/a"
else:
source_link_layer_address = "n/a"
payload_byte = ethChild2.child().get_bytes()
for payload_data in payload_byte:
payloadHex.append(hex(payload_data))
router_lifetime = payloadHex[2][2:] + payloadHex[3][2:]
elif str(ndp_message_number) == "135": #Neighbor Solicitation
for x in range(16):
target_address = target_address + packetHex[x][
2:].zfill(2)
if (x > 0):
if x % 2 != 0:
target_address = target_address + ":"
target_address = target_address[:-1]
target_link_layer_address = "n/a"
if str(contains_source) == "true-source":
for x in range(6):
source_link_layer_address = source_link_layer_address + packetHex[
x + offset + 1][2:].zfill(2) + ":"
source_link_layer_address = source_link_layer_address[:
-1]
else:
source_link_layer_address = "n/a"
elif str(ndp_message_number) == "136": #Neighbor Advertisement
flags = hex(ethChild2.child().get_bytes()[0:1][0])
if flags == "0xa0":
override_flag = True
router_flag = True
if str(contains_source
) == "true-source" and flags == "0xa0":
for x in range(6):
target_link_layer_address = target_link_layer_address + packetHex[
1 + offset + x][2:].zfill(2) + ":"
target_link_layer_address = target_link_layer_address[:
-1]
else:
target_link_layer_address = "n/a"
for x in range(16):
target_address = target_address + packetHex[x][
2:].zfill(2)
if (x > 0):
if x % 2 != 0:
target_address = target_address + ":"
target_address = target_address[:-1]
vlanId = self.check_vlanId(buf)
message_details = SLAAC_Message.SLAAC_Message(
vlanId, ndp_message_number, source_link_layer_address,
ip_source_address, ip_destination_address,
source_MAC_address_final, destination_MAC_address_final,
target_address, target_link_layer_address, override_flag,
router_flag, router_lifetime, getInterface)
detect_module = Detection.Detection()
if str(message_details.get_ndp_message_number()
) == "134": #Last Hop Router Attack
detect_module.detect_rogue_advertisement(message_details)
elif str(message_details.get_ndp_message_number()
) == "135": #Dos in DAD
if str(message_details.get_ip_source_address()) == "::":
detect_module.detect_dos_dad(message_details)
elif str(message_details.get_ndp_message_number()
) == "136": #Neigbor Spoofing
detect_module.detect_neighbor_spoofing((message_details))
except Exception, e:
pass
# runs the code every third frame to reduce load and make the laser slightly less jittery.
if frameCount % 1 is 0:
# Black background the game is drawn on
img = cv2.imread('testSmall.jpg')
# Blockers for the play area
#middleBlocker = Blocker.Blocker(middleX - 21, middleY - 19, middleX - 20, middleY + 21, middleX + 19, middleY + 20,
#middleX + 19, middleY - 21, img)
# HSV and blur
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
blur = ImageProcessingMethods.ourMedianBlur(hsv)
#blur = cv2.medianBlur(hsv, 13)
# Detection. Should return a box.
red_boxes = Detection.detectionRed(blur)
blue_boxes = Detection.detectionBlue(blur)
# Create mirrors and blockers from the detected boxes
mirrorBLockerList = []
#red_boxes.append(middleBlocker)
#middleBlocker.drawBlocker(img)
for i in range(len(red_boxes)):
point1, point2, point3, point4 = red_boxes[i]
x1, y1 = point1
x2, y2 = point2
x3, y3 = point3
x4, y4 = point4
tempBlocker = Blocker.Blocker(x1, y1, x2, y2, x3, y3, x4, y4, frame)
mirrorBLockerList.append(tempBlocker)
fracAVtoV = -0.016
Mzp = 20.
geffAV = {
"gu11": fracAVtoV,
"gd11": -fracAVtoV,
"gd22": -fracAVtoV,
"gl11": -fracAVtoV,
"gl22": -fracAVtoV
}
# Let us use a bit more the inner functions and make the decay limits for a combined V and AV operator for CHARM
exp = 'charm'
Delini = 0.1
Delf = 5
xeff, Limeff = de.MakeEffLimits(exp, lim.charm_decay.mx_ini,
lim.charm_decay.lim_ini, geffem, "V",
Delini)
xprod, Nprod = br.NProd(Delini, exp, geffem, "V") #
xifV, EffLimV = de.ShiftLimDel(xprod, Nprod, xeff, Limeff, Delf, Delini,
exp, "V", geffem)
xeff, Limeff = de.MakeEffLimits(exp, lim.charm_decay.mx_ini,
lim.charm_decay.lim_ini, geffAV, "AV",
Delini)
xprod, Nprod = br.NProd(Delini, exp, geffAV, "AV") #
xifAV, EffLimAV = de.ShiftLimDel(xprod, Nprod, xeff, Limeff, Delf, Delini,
exp, ("AV", "V"), (geffAV, geffem))
xif, EffLim = uf.CombineLimits((xifV, xifAV), (EffLimV, EffLimAV))
Dexp, Lexp, beamtype = de.GeomForExp(
exp) # Need to clean the above functions
EffLimFin_Low = de.ShortLamLimit(xif, Delf, EffLim, Dexp, Lexp, beamtype,
(geffAV, geffem), ("AV", "V"))
def readVideo(RGB_videoname, th_videoname, outputFolder):
time_ori = getOriginaltime(RGB_videoname, th_videoname)
# thermal processing
frame_IR = imageio.get_reader(th_videoname, 'ffmpeg')
IR_nframes = frame_IR._meta['nframes']
# RGB processing
frame_RGB = imageio.get_reader(RGB_videoname, 'ffmpeg')
RGB_nframes = frame_RGB._meta['nframes']
for th_num in range(1195, 1197):
sec_add = th_num / frame_IR._meta['fps']
#sec_add = 13.265
RGB_num = int((float(th_num) / IR_nframes) * RGB_nframes)
image_IR = frame_IR.get_data(th_num) #480*640*3
image_RGB = frame_RGB.get_data(RGB_num) #1080*1920*3
# plt.imshow(image_RGB)
# plt.show()
img_temp = image_RGB.copy()
bounding_boxes_th, bounding_boxes_RGB, human = Detection.Integrate(
image_IR, image_RGB)
bounding_boxes_B, object = Detection.hsv_thresholding(image_RGB)
time_final = time_ori + datetime.timedelta(
hours=0, minutes=0, seconds=sec_add)
time_final_string = getTimestr(time_final)
if human is True:
########################################################
#############################thermal#####################################
pixel_T = np.zeros((bounding_boxes_th.shape[0], 2)) #n*2
for i in range(bounding_boxes_th.shape[0]):
# img_temp = cv2.rectangle(img_temp, (bounding_boxes_th[i][0], bounding_boxes_th[i][1]),
# (bounding_boxes_th[i][0] + bounding_boxes_th[i][2],
# bounding_boxes_th[i][1] + bounding_boxes_th[i][3]),
# (255, 0, 0), 1)
# plt.imshow(img_temp)
# plt.show()
pixel_T[i, :] = np.array(
(bounding_boxes_th[i, 2] / 2 + bounding_boxes_th[i, 0],
bounding_boxes_th[i, 3] + bounding_boxes_th[i, 1]))
text_file_th.write(
"%s %s %s %s" %
(time_final_string, str(pixel_T[i, 0]), str(
pixel_T[i, 1]), "H\n")) #thermal folder + txt'H'
#plt.savefig()
########################################################
#################################RGB#####################################
pixel_R = np.zeros((bounding_boxes_RGB.shape[0], 2)) # n*2
for i in range(bounding_boxes_RGB.shape[0]):
bounding_boxes_RGB[i][0] += 106
bounding_boxes_RGB *= 1080 / 480
pixel_R[i, :] = np.array(
(bounding_boxes_RGB[i, 2] / 2 + bounding_boxes_RGB[i, 0],
bounding_boxes_RGB[i, 3] + bounding_boxes_RGB[i, 1]))
text_file_RGB.write(
"%s %s %s %s" %
(time_final_string, str(pixel_R[i, 0]), str(
pixel_R[i, 1]), "H\n")) #RGB folder + txt'H'
# img_temp = cv2.rectangle(img_temp, (bounding_boxes_RGB[i][0], bounding_boxes_RGB[i][1]),
# (bounding_boxes_RGB[i][0] + bounding_boxes_RGB[i][2],
# bounding_boxes_RGB[i][1] + bounding_boxes_RGB[i][3]),
# (255, 0, 0), 1)
# plt.imshow(img_temp)
# plt.show()
#plt.savefig()
if object is True:
pixel_R_B = np.zeros((bounding_boxes_B.shape[0], 2)) # n*2
for i in range(bounding_boxes_B.shape[0]):
pixel_R_B[i, :] = np.array(
(bounding_boxes_B[i, 2] / 2 + bounding_boxes_B[i, 0],
bounding_boxes_B[i, 3] / 2 + bounding_boxes_B[i, 1]))
text_file_th.write(
"%s %s %s %s" %
(time_final_string, str(pixel_R_B[i, 0]),
str(pixel_R_B[i, 1]), "H\n")) #RGB folder + txt'B'
points_angular = Data.rectangular_to_angular(averaged_points,
pixel_dimensions_m)
plt.figure('Radius Angle Data (pre-error min)'), plt.xlabel('angle [radians]'), plt.ylabel('r [m]'), plt.grid(True),\
plt.scatter(Data.theta_in_points(points_angular), Data.r_in_points(points_angular), s=0.2)
points_angular = Data.minimize_point_error(points_angular)
plt.figure('Radius Angle Data (post-error min)'), plt.xlabel('angle [radians]'), plt.ylabel('r [m]'), plt.grid(True),\
plt.scatter(Data.theta_in_points(points_angular), Data.r_in_points(points_angular), s=0.2)
points_rtime = Data.angular_to_rtime(points_angular, angular_velocity)
plt.figure('Radius Time Data'), plt.xlabel('t [s]'), plt.ylabel('r [m]'), plt.grid(True),\
plt.scatter(Data.t_in_points(points_rtime), Data.r_in_points(points_rtime), s=0.2)
plt.show()
stylus = Conversion.Stylus(points_rtime)
plt.figure('Velocity'), plt.xlabel('t [s]'), plt.ylabel('v [m/s]'), plt.ylabel('v [m/s]'), \
plt.grid(True), plt.scatter(stylus.get_time_axis(), stylus.get_velocity_axis(), s=0.2)
grooves = Detection.points_to_grooves(hist, bin_edges, inclusion_threshold,
Data.points_to_tuples(points_pixel))
for i, groove in enumerate(grooves):
plt.scatter(groove.get_theta_axis(), groove.get_rho_axis(),
s=0.2), plt.show()
# irregular_audio.append(Conversion.Stylus(groove, i + 1))
default='11:39:0')
args = parser.parse_args()
set_time = [args.morning, args.afternoon, args.evening]
name = ''
while True:
files= os.listdir('input')
preProcess = PreProcess()
index_new = preProcess.nameImage()
d = datetime.now()
cur_time = str(d.hour) +':'+ str(d.minute) + ':'+ str(d.second)
#capture
for i in range(len(set_time)):
if cur_time == set_time[i]:
preProcess.captureImage()
#resize & name
if len(files)>0:
for file in files:
sleep(3)
test = PreProcess(file=file, name=index_new)
test.preImages()
index_new = index_new +1
if index_new > 0:
detect = Detection()
detect.analyzing()
import Detection
import sys
import rospy
if __name__ == '__main__':
try:
print("----------------------------------------------------------")
print("Welcome to the MoveIt MoveGroup Python Interface Nursing")
print("----------------------------------------------------------")
print("Press Ctrl-D to exit at any time")
print("")
input("============ Press `Enter` to begin the process ...")
tutorial = MoveGroupPythonInterfaceNursing()
input("============ Go to the door knob ...")
node = Detection(0.9, 1, 10)
#patrol_test.move(4.61152219772, -5.15782785416, -0.37051665948, 0.928825820619)
input("============ Standby position ...")
tutorial.go_to_joint_state()
input("============ Stretch arm ...")
input("gripper_hold")
tutorial.gripper_hold()
input("gripper_release")
tutorial.gripper_release()
input(
"============ Press `Enter` to execute a movement using a pose goal ..."
action="store_true", default=False,
help="write diagnostic intermediate files")
(options, args) = parser.parse_args()
def getArg(ind, defValue):
if ind < len(args):
return args[ind]
return defValue
diaPath = getArg(0, defDiaPath)
policyPath = getArg(1, defPolicyPath)
diaExposure = afwImage.ExposureF()
diaExposure.readFits(diaPath)
diaMaskedImage = diaExposure.getMaskedImage()
diaWCS = diaExposure.getWcs()
policy = lsst.pex.policy.Policy.createPolicy(policyPath)
if options.debugIO:
policy.set("debugIO", True)
if options.verbosity > 0:
print "Verbosity =", options.verbosity
lsst.pex.logging.Trace_setVerbosity("lsst.detection", 9)
diaSources = Detection.detection(diaExposure, policy, 0)
for i in range(len(diaSources)):
diaSource_i = diaSources[i]
print diaSource_i.getColc(), " ", diaSource_i.getRowc(), " -> ", diaSource_i.getRa(), " ", diaSource_i.getDec()
