def funct1():
while True:
try:
account = Class.Player("*****@*****.**", "130206")
enter_result = account.gui_enter_account()[0]
fetch_results = account.fetch_reports()[0]
print(enter_result)
print(fetch_results)
reports = account.reports_result["Data"]["Report"]
world_datetime = account.reports_result["time"]
for report in reports:
report_datetime = report["date"]
if Tool.compare_GMT_time(world_datetime, report_datetime):
if report[
"type"] == "8" and "ownOffenderUnitDictionary" not in report[
"content"]: # только доклады битв и только оборона
if Tool.losses_ratio_counter(
report
): # если в докладах битвы что то стоющее
res = tripwire_real_detected(
account, report["id"], report["habitat"])
print("sent message for report {} with result {}".
format(report["id"], res[1]))
else:
res = account.delete_report(report["id"])
print("deleted report {} with result {}".format(
report["id"], res[0]))
print("waiting 10 mins...\n")
time.sleep(60 * 10)
except:
pass
def install(self, destDir=None, downloadDir=None, redownload=False, updateLocalSettings=False):
url = Settings.URL["BLLIP_SOURCE"]
if downloadDir == None:
downloadDir = os.path.join(Settings.DATAPATH) + "/tools/download"
if destDir == None:
destDir = Settings.DATAPATH + "/tools/BLLIP"
items = Download.downloadAndExtract(url, destDir, downloadDir + "/bllip.zip", None, False)
print >> sys.stderr, "Installing BLLIP parser"
Tool.testPrograms("BLLIP parser", ["make", "flex"], {"flex":"flex --version"})
parserPath = Download.getTopDir(destDir, items)
cwd = os.getcwd()
os.chdir(parserPath)
print >> sys.stderr, "Compiling first-stage parser"
subprocess.call("make", shell=True)
print >> sys.stderr, "Compiling second-stage parser"
subprocess.call("make reranker", shell=True)
os.chdir(cwd)
print >> sys.stderr, "Installing the McClosky biomedical parsing model"
url = "http://bllip.cs.brown.edu/download/bioparsingmodel-rel1.tar.gz"
Download.downloadAndExtract(url, destDir, downloadDir, None)
bioModelDir = os.path.abspath(destDir + "/biomodel")
# Check that everything works
Tool.finalizeInstall(["first-stage/PARSE/parseIt", "second-stage/programs/features/best-parses"],
{"first-stage/PARSE/parseIt":"first-stage/PARSE/parseIt " + bioModelDir + "/parser/ < /dev/null",
"second-stage/programs/features/best-parses":"second-stage/programs/features/best-parses -l " + bioModelDir + "/reranker/features.gz " + bioModelDir + "/reranker/weights.gz < /dev/null"},
parserPath, {"BLLIP_PARSER_DIR":os.path.abspath(parserPath),
"MCCLOSKY_BIOPARSINGMODEL_DIR":bioModelDir}, updateLocalSettings)
def run(self):
base = GlobalInfo.controls[self._number].get_base()
if base is None:
return TaskStatus.FAILURE
target = "map"
GlobalInfo.tf_listener.waitForTransform(target,base,rospy.Time(0),rospy.Duration(3.0))
(point,orientation) = GlobalInfo.tf_listener.lookupTransform(target,base,rospy.Time(0))
robotPos = Point(point[0],point[1],0)
robotYaw = Tool.yawFromTfQuaternion(orientation)
ballPos = GlobalInfo.ball.pose.pose.position
angleToBall = Tool.getAngle(robotPos,ballPos)
trans = Tool.Trans(robotPos, angleToBall)
trBallPos = trans.transform(ballPos)
distToBall = Tool.getSizeFromCenter(trBallPos)
trRobotYaw = trans.transformAngle(robotYaw)
if distToBall < self._threshDist \
and abs(trRobotYaw) < self._threshAngle:
return TaskStatus.SUCCESS
return TaskStatus.RUNNING
def run(self):
base = GlobalInfo.controls[self._number].get_base()
if base is None:
return TaskStatus.FAILURE
target = "map"
GlobalInfo.tf_listener.waitForTransform(target,base,rospy.Time(0),rospy.Duration(3.0))
(myPoint,myOrientation) = GlobalInfo.tf_listener.lookupTransform(target,base,rospy.Time(0))
myYaw = Tool.yawFromTfQuaternion(myOrientation)
poseStamped = GlobalInfo.tf_listener \
.transformPose("map",GlobalInfo.controls[self._number].target_pose)
targetPoint = poseStamped.pose.position
targetYaw = Tool.yawFromQuaternion(poseStamped.pose.orientation)
diff_x = abs(targetPoint.x - myPoint[0])
diff_y = abs(targetPoint.y - myPoint[1])
diff_yaw = abs(Tool.normalize(targetYaw - myYaw))
if diff_x < self._reachingPosThreshold \
and diff_y < self._reachingPosThreshold \
and diff_yaw < self._reachingAngleThreshold:
if rospy.get_time() - self.approach_time > self._keeping_time:
return TaskStatus.SUCCESS
else:
return TaskStatus.RUNNING
else:
self.approach_time = rospy.get_time()
return TaskStatus.RUNNING
def install(destDir=None, downloadDir=None, redownload=False, updateLocalSettings=False):
url = Settings.URL["BLLIP_SOURCE"]
if downloadDir == None:
downloadDir = os.path.join(Settings.DATAPATH) + "/tools/download"
if destDir == None:
destDir = Settings.DATAPATH + "/tools/BLLIP"
items = Download.downloadAndExtract(url, destDir, downloadDir + "/bllip.zip", None, False)
print >> sys.stderr, "Installing BLLIP parser"
Tool.testPrograms("BLLIP parser", ["make", "flex"], {"flex":"flex --version"})
parserPath = Download.getTopDir(destDir, items)
cwd = os.getcwd()
os.chdir(parserPath)
print >> sys.stderr, "Compiling first-stage parser"
subprocess.call("make", shell=True)
print >> sys.stderr, "Compiling second-stage parser"
subprocess.call("make reranker", shell=True)
os.chdir(cwd)
print >> sys.stderr, "Installing the McClosky biomedical parsing model"
url = "http://bllip.cs.brown.edu/download/bioparsingmodel-rel1.tar.gz"
Download.downloadAndExtract(url, destDir, downloadDir, None)
bioModelDir = os.path.abspath(destDir + "/biomodel")
# Check that everything works
Tool.finalizeInstall(["first-stage/PARSE/parseIt", "second-stage/programs/features/best-parses"],
{"first-stage/PARSE/parseIt":"first-stage/PARSE/parseIt " + bioModelDir + "/parser/ < /dev/null",
"second-stage/programs/features/best-parses":"second-stage/programs/features/best-parses -l " + bioModelDir + "/reranker/features.gz " + bioModelDir + "/reranker/weights.gz < /dev/null"},
parserPath, {"BLLIP_PARSER_DIR":os.path.abspath(parserPath),
"MCCLOSKY_BIOPARSINGMODEL_DIR":bioModelDir}, updateLocalSettings)
def draw(self, sheet):
if self.buttonPressed:
self.currentsize = (self.pressed_gfx.get_width(),
self.pressed_gfx.get_height())
sheet.blit(self.pressed_gfx, self.rect)
self.draw_relief(sheet, self.rect, "pressed")
elif self.buttonHovered:
self.currentsize = (self.hover_gfx.get_width(),
self.hover_gfx.get_height())
sheet.blit(self.hover_gfx, self.rect)
self.draw_relief(sheet, self.rect, "hover")
else:
self.currentsize = (self.normal_gfx.get_width(),
self.normal_gfx.get_height())
sheet.blit(self.normal_gfx, self.rect)
self.draw_relief(sheet, self.rect, "normal")
if self.overlay_gfx is not None:
sheet.blit(self.overlay_gfx,
Tool.center(self.overlay_gfx, self.rect))
if self.text is not None:
sheet.blit(self.text.obj, Tool.center(self.text.obj, self.rect))
def run(self):
base = GlobalInfo.controls[self._number].get_base()
if base is None:
return TaskStatus.FAILURE
nearestID = GlobalInfo.nearestEnemyID
if nearestID is None:
return TaskStatus.FAILURE
enemyBase = Tool.getEnemyBase(nearestID)
target = "map"
GlobalInfo.tf_listener.waitForTransform(target, enemyBase,
rospy.Time(0),
rospy.Duration(3.0))
(point, orientation) = GlobalInfo.tf_listener.lookupTransform(
target, enemyBase, rospy.Time(0))
yaw = Tool.yawFromTfQuaternion(orientation)
x = Constants.GoalFriend.x + 0.05
y = math.sin(yaw)
yLimit = Constants.GoalHalfSize - (Constants.RobotRadius + 0.05)
if y > yLimit:
y = yLimit
elif y < -yLimit:
y = -yLimit
targetYaw = 0
GlobalInfo.controls[self._number].setTargetPose(x, y, targetYaw, "map")
GlobalInfo.controls[self._number].setKickVelocity(0.0)
return TaskStatus.RUNNING
def BruteForce(pointList):
if len(pointList)<=3:
return pointList
#去重
pointList=list(set(pointList))
#固定A点
A = Tool.findIth(0,len(pointList)-1,pointList,1,lambda x,y:cmp(x[1],y[1]))
pointList.remove(A)
#枚举B,C,P
while 1:
dropList=[]
for b in range(0,len(pointList)-1):
for c in range(b+1,len(pointList)):
for p in range(0,len(pointList)):
if p==b or p==c:
continue
B=pointList[b]
C=pointList[c]
P=pointList[p]
if Tool.isInTriangle(A,B,C,P)==1:
dropList.append(P)
if len(dropList)==0:
break
#去重
dropList=list(set(dropList))
for p in dropList:
pointList.remove(p)
pointList.append(A)
return pointList
def run(self):
base = GlobalInfo.controls[self._number].get_base()
if base is None:
return TaskStatus.FAILURE
ballPos = GlobalInfo.ball.pose.pose.position
goalPos = Constants.GoalFriend
angleGoalToBall = Tool.getAngle(goalPos, ballPos)
angleGoalToBall *= -1.0
defensePos = self._calcu.calcuDefensePos(goalPos, angleGoalToBall)
defensePos, canReceive = Tool.convertToReceivePos(defensePos)
x = defensePos.x
y = defensePos.y
yaw = -Tool.getAngle(defensePos, ballPos)
GlobalInfo.controls[self._number].setTargetPose(x, y, yaw, "map", True)
shootVel = 0.0
dribblePower = 0.0
if canReceive:
shootVel = 8.0
dribblePower = 8.0
GlobalInfo.controls[self._number].setKickVelocity(
shootVel, dribblePower)
return TaskStatus.RUNNING
def send_message(account, reports_list, discussion_id, list_index):
message = ""
counter = 0
for report in reports_list:
index = list_index * Data.tripwire_data[
"reports_in_message"] + counter + 1
counter += 1
report_link = "l+k://report?" + str(report["id"]) + "&" + str(
report["habitat"]) + "&193"
try:
habitat_name = Tool.surrogate_decoding(
report["content"]["destinationHabitat"]["name"])
except:
habitat_name = "(/)название(/)"
try:
player_name = Tool.surrogate_decoding(
report["content"]["destinationHabitat"]["nick"])
except:
player_name = "(/)имя(/)"
message += "{}. {}\n{}\n{}\n{}\n\n".format(
index, Tool.current_time_in_msc(report["date"]), player_name,
habitat_name, report_link)
telegram.send_message(message)
print(message)
result = account.send_message(message, discussion_id)
print(result)
return result
def __init__(self,
x=0,
y=0,
overlay=None,
text=None,
font=pygame.font.SysFont(None, 12),
normal="gfx/UI/Natural/BtnNormal.png",
pressed="gfx/UI/Natural/BtnNormal.png",
hover="gfx/UI/Natural/BtnHover.png"):
self.pos = (x, y)
self._font = font
self.normal_gfx = Tool.load_image(normal)
self.pressed_gfx = Tool.load_image(pressed)
self.hover_gfx = Tool.load_image(hover)
self.currentsize = (self.normal_gfx.get_width(),
self.normal_gfx.get_height())
self.place(x, y)
self.overlay_gfx = overlay
self.buttonPressed = False
self.buttonHovered = False
self.lastMouseevent = False
self.text = None
self.reliefsize = 3
if overlay is not None:
self.load_overlay(overlay)
if text is not None:
self.set_text(text)
def on_init(self):
self.id = "denoise"
self.name = "Denoise"
self.icon_path = "ui/PF2_Icons/Denoise.png"
self.properties = [
# Detailer
Tool.Property("enabled",
"Denoise",
"Header",
False,
has_toggle=True,
has_button=False),
Tool.Property("strength", "Strength", "Slider", 0, max=100, min=0),
Tool.Property("w_strength",
"White Strength",
"Slider",
20,
max=100,
min=0),
Tool.Property("b_strength",
"Black Strength",
"Slider",
70,
max=100,
min=0),
Tool.Property("method",
"Method",
"Combo",
0,
options=[
"Mean",
"Gaussian",
]),
]
def run(self):
base = GlobalInfo.controls[self._number].get_base()
if base is None:
return TaskStatus.RUNNING
ballPos = GlobalInfo.ball.pose.pose.position
defensePos = self._calcu.calcuDefensePos()
defensePos, canReceive = Tool.convertToReceivePos(defensePos)
angleToBall = Tool.getAngle(defensePos, ballPos)
x = defensePos.x
y = defensePos.y
yaw = angleToBall
GlobalInfo.controls[self._number].setTargetPose(x,y,yaw,"map",True)
shootVel = 0.0
if canReceive:
shootVel = 8.0
GlobalInfo.controls[self._number].setKickVelocity(shootVel)
return TaskStatus.RUNNING
def run(self):
base = GlobalInfo.controls[self._number].get_base()
if base is None:
return TaskStatus.FAILURE
target = "map"
GlobalInfo.tf_listener.waitForTransform(target,base,rospy.Time(0),rospy.Duration(3.0))
(point,orientation) = GlobalInfo.tf_listener.lookupTransform(target,base,rospy.Time(0))
robotYaw = Tool.yawFromTfQuaternion(orientation)
ballPos = GlobalInfo.ball.pose.pose.position
kickTarget = GlobalInfo.controls[self._number].getKickTarget()
angleToTarget = Tool.getAngle(ballPos, kickTarget)
x,y = ballPos.x, ballPos.y
diffAngle = Tool.normalize(angleToTarget - robotYaw)
kickVelocity = 0.0
if abs(diffAngle) < self._threshKickAngle:
kickVelocity = self._velocity
GlobalInfo.controls[self._number].setTargetPose(x,y,angleToTarget,"map")
GlobalInfo.controls[self._number].setKickVelocity(kickVelocity)
return TaskStatus.RUNNING
def takePhotos(ID, name, message):
"""
Function to take the photo
This function will detect the faces and
"""
# Check the validity of id and name
if o_tl.checkInteger(ID) and name.isalpha():
# Default webcam
cam = Camera(0)
count = 1
while True:
# Prepare camera and get frames (images)
img, gray = cam.getFrames()
# Using built-in function detectMultiScale for face detection
faces = detector.detectMultiScale(gray, 1.05, 5)
for (x, y, w, h) in faces:
# Draw rectangle around face
cv2.rectangle(img, (x, y), (x + w, y + h), (0, 128, 255), 2)
# Incrementing number of sample
count = count + 1
# Saving the captured face in the dataset folder RawCapturedPicture
cv2.imwrite(
'../RawCapturedPicture/' + str(name) + "_" + str(ID) +
'_' + str(count) + ".jpg", gray[y:y + h, x:x + w])
# Display the frame
cv2.imshow('Capture', img)
# Wait for 100 miliseconds
if cv2.waitKey(100) & 0xFF == ord('q'):
break
# Break if the number of frames is more than 100
elif count > 100:
break
# Release and destroy all windows
cam.releaseCam()
# Store data in the excel
res = str(ID) + " - " + str(name) + " - " + "Success!"
row = [ID, name]
with open('../Students/StudentsList.csv', 'a+') as csvFile:
writer = csv.writer(csvFile)
writer.writerow(row)
csvFile.close()
message.configure(text=res)
else:
if o_tl.checkInteger(ID):
res = "Enter The Right Name"
message.configure(text=res)
if name.isalpha():
res = "Enter Right Numerical ID"
message.configure(text=res)
def run(self):
base = GlobalInfo.controls[self._number].get_base()
if base is None:
return TaskStatus.RUNNING
ballPos = GlobalInfo.ball.pose.pose.position
goalPos = Constants.GoalFriend
shootVel = 0.0
avoidBall = True
angleBallToGoal = Tool.getAngle(ballPos, goalPos)
# ボールが敵ディフェンスエリアにあれば離れる
dist = self._distToBall
defensePos = ballPos
if AnalystTool.isInDefenceArea(False, ballPos, 1.25):
dist = self._longDistToBall
trans = Tool.Trans(ballPos, angleBallToGoal)
trDefensePos = Point(dist, 0, 0)
defensePos = trans.invertedTransform(trDefensePos)
else:
target = "map"
GlobalInfo.tf_listener.waitForTransform(target, base,
rospy.Time(0),
rospy.Duration(3.0))
(point, orientation) = GlobalInfo.tf_listener.lookupTransform(
target, base, rospy.Time(0))
robotPos = Point(point[0], point[1], 0)
trans = Tool.Trans(ballPos, angleBallToGoal)
trRobotPos = trans.transform(robotPos)
# 味方ゴールとボールの直線上にいれば、ボールに向かう
if abs(trRobotPos.y) < 0.3:
dist = 0
shootVel = 8.0
avoidBall = False
trDefensePos = Point(dist, 0, 0)
defensePos = trans.invertedTransform(trDefensePos)
defensePos, canReceive = Tool.convertToReceivePos(defensePos)
x = defensePos.x
y = defensePos.y
yaw = Tool.ivertAngle(angleBallToGoal)
GlobalInfo.controls[self._number] \
.setTargetPose(x,y,yaw,"map",avoidBall)
if canReceive:
shootVel = 8.0
GlobalInfo.controls[self._number].setKickVelocity(shootVel)
return TaskStatus.RUNNING
def resampling(jp2_images_dir, resampled_images_dir, zip_path_list):
tl.extract_zip(jp2_images_dir, zip_path_list)
band_name = ''
for jp2_directory in os.listdir(jp2_images_dir):
resampled_images_specprod_dir = resampled_images_dir + jp2_directory
os.mkdir(resampled_images_specprod_dir)
jp2_files_list = []
for root, dirnames, filenames in os.walk(jp2_images_dir +
jp2_directory):
for filename in filenames:
jp2_files_list.append(os.path.join(root, filename))
height_10m, width_10m = tl.get10mFeatures(jp2_files_list)
for jp2_image in jp2_files_list:
if '10m' in jp2_image:
tl.convertJP2toTIF(jp2_image, resampled_images_specprod_dir)
print 'Copied file: ', jp2_image
continue
else:
for band_name in resizing_band_list:
if band_name in jp2_image:
break
dataset = rasterio.open(
jp2_image, driver='JP2OpenJPEG'
) # Immagine di cui devo fare il resampling
src_arr = dataset.read(1) # Array di cui devo fare il resampling
aff = dataset.transform
resampled_arr = np.empty(
(height_10m, width_10m),
dtype=src_arr.dtype) # Array di destinazione
x = height_10m / src_arr.shape[1] # Upsampling
newaff = Affine(aff.a / x, aff.b, aff.c, aff.d, aff.e / x, aff.f)
reproject(
# source parameters
source=src_arr,
src_crs=dataset.crs,
src_transform=dataset.transform,
# dest parameters
destination=resampled_arr,
dst_crs=dataset.crs,
dst_transform=newaff,
resampling=Resampling.nearest)
resampled_file_name = resampled_images_specprod_dir + '/' + 'resampled_image_' \
+ str(band_name) + '_10m.tif'
resampled_image = rasterio.open(resampled_file_name,
'w',
height=resampled_arr.shape[0],
width=resampled_arr.shape[1],
count=1,
dtype=resampled_arr.dtype,
driver='GTiff',
crs=dataset.crs,
transform=newaff)
resampled_image.write(resampled_arr, 1)
resampled_image.close()
dataset.close()
print 'Resampled file: ', resampled_file_name
def Init():
global background_photo
background_photo = pygame.image.load('BackgroundIce.png')
background_photo = pygame.transform.scale(
background_photo, (int(display_width * 0.6), display_height))
Tool.Init(game_display, display_width, display_height, clock)
Tool.AddSound("Hurt", pygame.mixer.Sound('短慘叫.wav'))
Tool.AddSound("Death", pygame.mixer.Sound('長慘叫.wav'))
Tool.AddSound("Yay", pygame.mixer.Sound('耶.wav'))
def load(self, source):
"""
读取json格式数据，source为json字符串。若遇到json格式错误，抛出异常。
"""
start = Tool.escape_whitespace(source, 0)
obj, end = self._decode(source, start)
end = Tool.escape_whitespace(source, end)
if end != len(source):
raise ValueError(Tool.errmsg("Extra data", source, end, len(source)))
return obj
def generate_usecase_infomation():
for root, dirs, files in os.walk(input_usecase_directory):
for file in files:
information = ""
output_filename = ""
foRead = open(os.path.join(root, file), "r", encoding="UTF-8")
for line in foRead:
line_array = line.split(" : ")
if len(line_array) != 2:
continue
# print(file, "array length =", len(line_array))
title = line_array[0].strip()
content = line_array[1].strip()
if title == "file name":
information += "file name : " + content + "\n"
output_filename = content
continue
content = content.lower()
content = content.replace("(none)", "")
remove_list = Tool.get_remove_list()
for item in remove_list:
content = content.replace(item, "")
content_array = content.split(" ")
convert_dict = Tool.get_convert_dict()
for index in range(len(content_array)):
if content_array[index] in convert_dict:
content_array[index] = convert_dict[
content_array[index]]
for index in range(len(content_array)):
if content_array[index] in convert_dict:
content_array[index] = convert_dict[
content_array[index]]
stopword_list = Tool.get_stopword_list()
content_array = [
word for word in content_array if word not in stopword_list
]
content_array = [
word for word in content_array if not Tool.is_number(word)
]
information += title + " : " + str(content_array) + "\n"
output_path = output_usecase_directory + output_filename + ".txt"
foWrite = open(output_path, "w", encoding="UTF-8")
foWrite.write(information)
foWrite.close()
def install(destDir=None, downloadDir=None, redownload=False, updateLocalSettings=False):
print >> sys.stderr, "Installing Stanford Parser"
if downloadDir == None:
downloadDir = os.path.join(Settings.DATAPATH, "tools/download/")
if destDir == None:
destDir = os.path.join(Settings.DATAPATH, "tools/")
items = Download.downloadAndExtract(Settings.URL["STANFORD_PARSER"], destDir, downloadDir)
stanfordPath = Download.getTopDir(destDir, items)
Tool.finalizeInstall(["stanford-parser.jar"],
{"stanford-parser.jar":"java -cp stanford-parser.jar:slf4j-api.jar edu.stanford.nlp.trees.EnglishGrammaticalStructure"},
stanfordPath, {"STANFORD_PARSER_DIR":stanfordPath}, updateLocalSettings)
def install(self, destDir=None, downloadDir=None, redownload=False, updateLocalSettings=False):
print >> sys.stderr, "Installing Stanford Parser"
if downloadDir == None:
downloadDir = os.path.join(Settings.DATAPATH, "tools/download/")
if destDir == None:
destDir = os.path.join(Settings.DATAPATH, "tools/")
items = Download.downloadAndExtract(Settings.URL["STANFORD_PARSER"], destDir, downloadDir)
stanfordPath = Download.getTopDir(destDir, items)
Tool.finalizeInstall(["stanford-parser.jar"],
{"stanford-parser.jar":"java -cp stanford-parser.jar edu.stanford.nlp.trees.EnglishGrammaticalStructure"},
stanfordPath, {"STANFORD_PARSER_DIR":stanfordPath}, updateLocalSettings)
def on_init(self):
self.id = "exposure"
self.name = "Exposure"
self.icon_path = "ui/PF2_Icons/Exposure.png"
self.properties = [
# Detailer
Tool.Property("enabled", "Exposure", "Header", False, has_toggle=False, has_button=False),
Tool.Property("exposure", "Overall Exposure", "Slider", 0, max=50, min=-50),
Tool.Property("h_exposure", "Highlight Exposure", "Slider", 0, max=50, min=-50),
Tool.Property("m_exposure", "Midtone Exposure", "Slider", 0, max=50, min=-50),
Tool.Property("s_exposure", "Shadow Exposure", "Slider", 0, max=50, min=-50),
]
def testDecisionBoundary(self):
print("\n\n>> Display the decision boundary to classify an iris in one of the two classes: setosa, versicolor")
df=self.loadIrisData()
# build training set with 100 records: the label is in column 5
y=df.iloc[0:100,4].values
# transform the classed to numerical value
y = np.where( y == 'Iris-setosa', -1, 1)
# take the columns 0,1: sepal and petal length as variables
X=df.iloc[0:100,[0,2]].values
ppn = Perceptron(0.01,10)
ppn.fit(X,y)
tool.displayDecisionRegions( X, y, classifier = ppn,
xlabel='sepal length [std]',ylabel='petal length [std]',label0='Setosa',label1='Versicolor')
def init_game(self, dictstate):
self.cardname_list = [
"card_sunflower",
'card_peashooter',
'card_snowpea',
'card_wallnut',
'card_cherrybomb',
'card_threepeater',
'card_squash',
'card_jalapeno',
]
if 'select_cards' in dictstate:
self.card_list = dictstate['select_cards']
self.money = 30000
if "money" in dictstate:
self.money = dictstate['money']
self.done = False
self.current_time = dictstate['current_time']
card_x_length = 53
card_y_length = 74
grid_x = 9
grid_y = 5
#self.UpperCard_TotalOffSet_X = C.Constant_PlantSelection_LayOut.Upper_Panel_Card_Offset_X + C.Constant_PlantSelection_LayOut.Upper_Panel_Offset_X
self.UpperCard_TotalOffSet_X = 78
#self.UpperCard_TotalOffSet_Y=C.Constant_PlantSelection_LayOut.Upper_Panel_Offset_Y+ C.Constant_PlantSelection_LayOut.Upper_Panel_Card_Offset_y
self.UpperCard_TotalOffSet_Y = 8
#下面的是用来选牌用的
self.card_grid = Tool.Grid(1, 8, self.UpperCard_TotalOffSet_X,
self.UpperCard_TotalOffSet_Y, card_x_length,
card_y_length)
#
self.map_grid = Tool.Grid(grid_y, grid_x, 30, 80, 80, 100)
self.plant_position_map = [[True for j in range(grid_x)]
for i in range(grid_y)]
for i, card_name in enumerate(self.cardname_list):
single_card_image = Tool.All_Images[card_name]
single_card_image = Tool.get_surface_from_image_samesize(
single_card_image)
card_spirte_info = Tool.get_plant_info_from_card_name(card_name)
plant_name, plant_freezetime, plant_cost = card_spirte_info
plant_sprite_images = Tool.All_Images[plant_name]
single_card = Card(self.card_grid, i, card_name, single_card_image,
plant_cost, plant_freezetime, self.current_time)
self.card_list.append(single_card)
self.card_to_sprite_image[card_name] = plant_sprite_images
def main_func():
print "Welcome to the Monitor state"
keyboard.Path()
print "Select Menu:\n1. Monitor State\n2. Manual Mode\n3. Exit\n"
c = keyboard.Choice()
if c == 1:
Tool.start_tool()
else:
print "Bye Bye "
sys.exit(0)
def on_init(self):
self.id = "blur"
self.name = "Blur"
self.icon_path = "ui/PF2_Icons/Blur.png"
self.properties = [
# Detailer
Tool.Property("enabled", "Blur", "Header", False, has_toggle=True, has_button=False),
Tool.Property("method", "Method", "Combo", 1, options=[
"Guassian",
"Average",
"Median"
]),
Tool.Property("strength", "Strength", "Slider", 5, max=100, min=0),
]
def Loss_SpatialSmooth(X, W, Ind):
'''
function to return spatial smoothness constraint loss
:param X: Input point cloud float B*N*3
:param W: Input knn weight matrix float B*N*Knn
:param Ind: Input knn index int B*N*Knn
:return: spatial smooth loss
'''
knn = W.get_shape()[-1].value
# unstacked_X = tf.unstack(X,axis=0)
# unstacked_Ind = tf.unstack(Ind,axis=0)
#
# X_tilde = []
# for X_b, Ind_b in zip(unstacked_X,unstacked_Ind):
#
# X_tilde.append(tf.gather(X_b,Ind_b))
X_tilde = Tool.batch_gather_v1(X, Ind) # indexed X B*N*Knn*3
# X_tilde = tf.stack(X_tilde,axis=0) # indexed X B*N*Knn*3
X_expand = tf.tile(X[:, :, tf.newaxis, :],
[1, 1, knn, 1]) # expanded X B*N*Knn*3
loss = tf.reduce_mean(W * tf.reduce_sum((X_expand - X_tilde)**2, axis=-1))
return loss
def DoGCodeCallsForPass(self, finishing_pass):
failure = self.CheckToolExists()
if failure: return failure
tool = Tool.FindTool(self.tool_number)
depthparams = self.GetDepthParams()
if not finishing_pass or self.only_finishing_pass:
SpeedOp.DoGCodeCalls(self)
if self.auto_roll_on or self.auto_roll_off:
roll_radius = self.auto_roll_radius / wx.GetApp().program.units
else:
roll_radius = None
depth_params = self.GetDepthParams()
tool_diameter = tool.CuttingRadius(True) * 2.0
cutting_edge_angle = tool.cutting_edge_angle
if finishing_pass:
feedrate_hv(self.finishing_h_feed_rate / wx.GetApp().program.units,
self.vertical_feed_rate / wx.GetApp().program.units)
flush_nc()
offset_extra = 0.0
depth_params.step_down = self.finishing_step_down
depth_params.z_finish_depth = 0.0
else:
offset_extra = self.offset_extra / wx.GetApp().program.units
cut_mode = self.finishing_cut_mode if finishing_pass else self.cut_mode
self.DoEachSketch(self.DoGCodeCallsForSketch,
(cut_mode, depth_params, tool_diameter, roll_radius,
offset_extra, cutting_edge_angle))
def StartButton():
button_width_factor = 0.18
button_height_factor = 0.1
Tool.Button(game_display, "START", display_width / 2 * 0.8,
display_height * 0.65, display_width * button_width_factor,
display_height * button_height_factor, Tool.green,
Tool.bright_green, StartGame)
def EnableAndSetCornerFlatAndAngle(self):
type = Tool.GetToolTypeValues()[self.cmbToolType.GetSelection()]
if type == TOOL_TYPE_DRILL or type == TOOL_TYPE_CENTREDRILL:
self.lgthCornerRadius.Enable(False)
self.lgthCornerRadius.SetLabel("")
self.lgthFlatRadius.Enable(False)
self.lgthFlatRadius.SetLabel("")
self.lgthCuttingEdgeAngle.Enable()
self.lgthCuttingEdgeAngle.SetValue(self.object.cutting_edge_angle)
elif type == TOOL_TYPE_ENDMILL or type == TOOL_TYPE_SLOTCUTTER:
self.lgthCornerRadius.Enable()
self.lgthCornerRadius.SetValue(self.object.corner_radius)
self.lgthFlatRadius.Enable(False)
self.lgthFlatRadius.SetLabel("")
self.lgthCuttingEdgeAngle.Enable(False)
self.lgthCuttingEdgeAngle.SetLabel("")
elif type == TOOL_TYPE_BALLENDMILL:
self.lgthCornerRadius.Enable(False)
self.lgthCornerRadius.SetLabel("")
self.lgthFlatRadius.Enable(False)
self.lgthFlatRadius.SetLabel("")
self.lgthCuttingEdgeAngle.Enable(False)
self.lgthCuttingEdgeAngle.SetLabel("")
elif type == TOOL_TYPE_CHAMFER or type == TOOL_TYPE_ENGRAVER:
self.lgthCornerRadius.Enable(False)
self.lgthCornerRadius.SetLabel("")
self.lgthFlatRadius.Enable()
self.lgthFlatRadius.SetValue(self.object.flat_radius)
self.lgthCuttingEdgeAngle.Enable()
self.lgthCuttingEdgeAngle.SetValue(self.object.cutting_edge_angle)
def __init__(self, name, tool, models=None, claims=None):
global maxnamelen, maxclaimlen
self.name = name
if len(name) > maxnamelen:
maxnamelen = len(name)
self.toolname = tool
self.claims = claims
for cl in self.claims:
if len(cl) > maxclaimlen:
maxclaimlen = len(cl)
self.models = models
Tool.register(self.toolname, self)
def run(self):
base = GlobalInfo.controls[self._number].get_base()
if base is None:
return TaskStatus.RUNNING
ballPos = GlobalInfo.ball.pose.pose.position
waitPos = Point()
waitPos.y = -ballPos.y
if waitPos.y > self._waitPosYLimit:
waitPos.y = self._waitPosYLimit
elif waitPos.y < -self._waitPosYLimit:
waitPos.y = -self._waitPosYLimit
# ボールとwaitPos間に敵ロボットがいないかチェック
for waitX in self._waitPosXList:
waitPos.x = waitX
if AnalystTool.isNoObstacle(ballPos, waitPos):
break
x = waitPos.x
y = waitPos.y
yaw = Tool.getAngle(waitPos, ballPos)
GlobalInfo.controls[self._number] \
.setTargetPose(x, y, yaw, "map", True)
GlobalInfo.controls[self._number].setKickVelocity(0.0)
return TaskStatus.RUNNING
def merge():
gr_df = pd.DataFrame(pd.read_csv('OutputGSAT.csv', dtype='str'))
citypp_df = pd.DataFrame(pd.read_csv('OutputGrVsCityPP.csv', dtype='str'))
dd_df = pd.DataFrame(pd.read_csv('OutputGrVsDurl.csv', dtype='str'))
salary_df = pd.DataFrame(pd.read_csv('OutputGrVsSalary.csv', dtype='str'))
ud_df = pd.DataFrame(pd.read_csv('OutputGrVsUurl.csv', dtype='str'))
for x in range(len(gr_df)):
for y1 in range(len(citypp_df)):
if gr_df['DID'][x] == citypp_df['DID'][y1]:
gr_df['City'][x] = citypp_df['City'][y1]
gr_df['PP'][x] = citypp_df['PP'][y1]
for y2 in range(len(dd_df)):
if gr_df['DID'][x] == dd_df['DID'][y2]:
gr_df['DURL'][x] = dd_df['DURL'][y2]
for y3 in range(len(salary_df)):
if gr_df['DID'][x] == salary_df['DID'][y3]:
gr_df['Salary'][x] = salary_df['Salary'][y3]
gr_df['SalaryURL'][x] = salary_df['SalaryURL'][y3]
for y4 in range(len(ud_df)):
if gr_df['DID'][x] == ud_df['DID'][y4]:
gr_df['UURL'][x] = ud_df['UURL'][y4]
gr_df.to_csv("D.csv", encoding="utf_8_sig", index=False)
Tool.SaveDatabase(gr_df, "D")
def install(destDir=None, downloadDir=None, redownload=False, updateLocalSettings=False):
print >> sys.stderr, "Installing GENIA Sentence Splitter"
if downloadDir == None:
downloadDir = os.path.join(Settings.DATAPATH, "tools/download/")
if destDir == None:
destDir = os.path.join(Settings.DATAPATH, "tools/geniass")
Download.downloadAndExtract(Settings.URL["GENIA_SENTENCE_SPLITTER"], destDir, downloadDir, "geniass")
print >> sys.stderr, "Compiling GENIA Sentence Splitter"
Tool.testPrograms("Genia Sentence Splitter", ["make", "ruby"])
cwd = os.getcwd()
os.chdir(destDir)
print >> sys.stderr, "Compiling Genia Sentence Splitter"
subprocess.call("make", shell=True)
os.chdir(cwd)
Tool.finalizeInstall(["./run_geniass.sh"],
{"./run_geniass.sh":"./run_geniass.sh README /dev/null " + Settings.RUBY_PATH},
destDir, {"GENIA_SENTENCE_SPLITTER_DIR":destDir}, updateLocalSettings)
def install(destDir=None, downloadDir=None, redownload=False, compile=False, javaHome=None, updateLocalSettings=False):
print >> sys.stderr, "Installing BANNER"
if downloadDir == None:
downloadDir = os.path.join(Settings.DATAPATH, "tools/download")
if destDir == None:
destDir = Settings.DATAPATH
if compile:
Download.downloadAndExtract(Settings.URL["BANNER_SOURCE"], destDir + "/tools/BANNER", downloadDir + "/banner.tar.gz", "trunk", False, redownload=redownload)
print >> sys.stderr, "Compiling BANNER with ANT"
Tool.testPrograms("BANNER", ["ant"], {"ant":"ant -version"})
#/usr/lib/jvm/java-6-openjdk
if javaHome == None or javaHome.strip() == "":
subprocess.call("cd " + destDir + "/tools/BANNER; ant -f build_ext.xml", shell=True)
else:
subprocess.call("cd " + destDir + "/tools/BANNER; export JAVA_HOME=" + javaHome + "; ant -f build_ext.xml", shell=True)
else:
print >> sys.stderr, "Downloading precompiled BANNER"
Download.downloadAndExtract(Settings.URL["BANNER_COMPILED"], destDir + "/tools", downloadDir, redownload=redownload)
Tool.finalizeInstall([], None, destDir + "/tools/BANNER", {"BANNER_DIR":destDir + "/tools/BANNER"}, updateLocalSettings)
def gvimRunning(self):
"""Check if Gvim is still running."""
if self.gvim_open:
if gvimHasNetbeans(self.topmodel):
# gvim_open flag is set and reset appropriately.
return 1
# No netbeans connection: need to check if the process is still
# there.
if Tool.stillRunning(self.gvim_open):
return 1
self.gvim_open = 0
return 0
def fileOpened(self, name):
"""Invoked when a fileOpened event was received from Gvim, passed on to
the main thread."""
# Let the generic stuff find a node for this name and add the tool to
# the item.
node = Tool.toolOpenedFile(self, name)
# Add a buffer for the node.
buf = self.buffers.get(node)
if not buf:
self.lastbuffer = self.lastbuffer + 1
buf = GvimBuffer(self.lastbuffer)
self.buffers[node] = buf
if self.handler:
# Let Gvim know which buffer number we use for this file.
self.handler.sendCmd(buf.nr, "putBufferNumber", ' "%s"' % self.escapeStringArg(node.fullName()))
# We don't want changes to be reported
self.handler.sendCmd(buf.nr, "stopDocumentListen")
# May show breakpoints in the newly opened file.
Tool.updateBreakpoints(self, node)
def _decode_list(self, string, index):
values = []
nextchar = string[index:index + 1]
if nextchar in Tool.WhiteSpace:
index = Tool.escape_whitespace(string, index + 1)
nextchar = string[index:index + 1]
if nextchar == ']':
return values, index + 1
while True:
try:
value, index = self._decode(string, index)
except StopIteration:
raise ValueError(Tool.errmsg("Expecting object", string, index))
values.append(value)
nextchar = string[index:index + 1]
if nextchar in Tool.WhiteSpace:
index = Tool.escape_whitespace(string, index + 1)
nextchar = string[index:index + 1]
index += 1
if nextchar == ']':
break
elif nextchar != ',':
raise ValueError(Tool.errmsg("Expecting , delimiter", string, index))
try:
if string[index] in Tool.WhiteSpace:
index += 1
if string[index] in Tool.WhiteSpace:
index = Tool.escape_whitespace(string, index + 1)
except IndexError:
pass
return values, index
def foreground(self, item, node=None, lnum=None):
"""Move this Tool to the foreground, with the current activity.
When "item" is not None edit this item.
When "node" is not None edit this node."""
winposarg = '"+winpos %d %d" "+set lines=30 columns=82" ' % (self.topmodel.view.GetSize().width + 10, 0)
if item:
node = item.node
# Start a Vim server on the file.
if gvimHasNetbeans(self.topmodel):
self.gvimRunNetbeans(winposarg)
if self.handler:
if node:
self.currentnode = node
self.gvimOpenFile(node)
else:
self.handler.sendCmd(0, "raise")
else:
running = self.gvimRunning()
cmd = "%s -f --servername AAPGVIM " % gvimProgName(self.topmodel)
# Jump to the node when it's specified, the user may have started
# editing another file.
if not running or node:
# Position the Vim window next to ours and bring it to the
# front.
cmd = cmd + winposarg
if node:
if lnum:
pos = "+%d " % lnum
else:
pos = ""
cmd = cmd + ('--remote-silent %s"%s"' % (pos, node.fullName()))
if item:
self.setCurrentItem(item)
else:
self.currentnode = node
else:
cmd = cmd + '--remote-send "<C-\\><C-N>:call foreground()<CR>"'
if not running:
self.gvim_start_time = time.time()
self.gvim_open = Tool.spawn(cmd)
else:
self.gvimWait()
os.system(cmd)
def _decode_float_int(self, string, index):
integer = ''
frac = ''
exp = ''
isInt = True
isFrac = False
isExp = False
while True:
if len(string) == index:
break
nextchar = string[index]
if nextchar in Tool.WhiteSpace:
index = Tool.escape_whitespace(string, index)
elif nextchar == '-' or nextchar == '+' or ('0' <= nextchar <= '9'):
if isInt:
integer += nextchar
index += 1
elif isFrac and not isExp:
frac += nextchar
index += 1
elif isExp:
exp += nextchar
index += 1
elif nextchar == '.':
isInt = False
isFrac = True
frac += nextchar
index += 1
elif nextchar == 'e' or nextchar == 'E':
isExp = True
exp += nextchar
index += 1
else:
break
if isFrac:
res = float(integer + frac + exp)
else:
res = int(integer)
return res, index
def Graham_Scan(pointlist): #构造有序list point = Tool.findIth(0,len(pointlist)-1,pointlist,1,comparePointX)#获取最左边点 uplist = [] downlist=[] otherlist=[] for w in pointlist: if w[0]==point[0] and w[1]==point[1]: continue elif w[0]==point[0] and w[1]>point[1]: uplist.append((w,'+')) elif w[0]==point[0] and w[1]<point[1]: downlist.append((w,'-')) else: otherlist.append((w,float(w[1]-point[1])/(w[0]-point[0]))) #排序 uplist.sort(cmp=lambda x,y:comparePointY(x[0],y[0]),reverse=True)#降序 downlist.sort(cmp=lambda x,y:comparePointY(x[0],y[0]))#升序 otherlist.sort(cmp=lambda x,y:cmp(x[1],y[1]))#按斜率升序 #合并为一个有序list list=[] list.append(point) for w in downlist: list.append(w[0]) for w in otherlist: list.append(w[0]) for w in uplist: list.append(w[0]) #Graham-Scan stack = [] if len(list)<3: return list for w in range(3): stack.append(list.pop(0)) for w in range(len(list)): next = list.pop(0) while isLeftMove(stack[-2],stack[-1],next,point)=='right': stack.pop() if len(stack)<=2: break stack.append(next) return stack
def cfg_host(self, nameport, *args):
np = Tool.hostport(nameport, Defaults.PORT)
name = np[0]
port = len(np)>1 and Tool.intval(np[1]) or _PORT
pw = len(np)>2 and np[2] or ''
sa = socket.getaddrinfo(name, port)
if not sa:
Log.err("cannot resolve %s",name)
return
for a in sa:
if a[0] != socket.AF_INET and a[0] != socket.AF_INET6:
Log.warn("wrong family {0} for {1}", Tool.sockfam(a[0]), name)
continue
if a[1] != socket.SOCK_DGRAM:
Log.info("ignore type {0} for {1}", Tool.socktype(a[1]), name)
continue
if a[2] != socket.IPPROTO_UDP:
Log.info("ignore proto {0} for {1}", Tool.sockproto(a[2]), name)
continue
Log.info("host {0}: {2} {1}", name, a[4], Tool.sockfam(a[0]))
self.target.add(a[0], a[4], pw)
def _decode_dict(self, string, index):
values = []
nextchar = string[index:index + 1]
if nextchar != '"':
if nextchar in Tool.WhiteSpace:
index = Tool.escape_whitespace(string, index)
nextchar = string[index:index + 1]
if nextchar == '}':
values = {}
return values, index + 1
elif nextchar != '"':
raise ValueError(Tool.errmsg("Expecting property name", string, index))
index += 1
while True:
key, index = self._decode_string(string, index)
if string[index: index + 1] != ':':
index = Tool.escape_whitespace(string, index)
if string[index:index + 1] != ':':
raise ValueError(Tool.errmsg("Expecting : delimiter", string, index))
index += 1
try:
if string[index] in Tool.WhiteSpace:
index += 1
if string[index] in Tool.WhiteSpace:
index = Tool.escape_whitespace(string, index + 1)
except IndexError:
pass
try:
value, index = self._decode(string, index)
except StopIteration:
raise ValueError(Tool.errmsg("Expecting object", string, index))
values.append((key, value))
try:
nextchar = string[index]
if nextchar in Tool.WhiteSpace:
index = Tool.escape_whitespace(string, index)
nextchar = string[index]
except IndexError:
nextchar = ''
index += 1
if nextchar == '}':
break
elif nextchar != ',':
raise ValueError(Tool.errmsg("Expecting , delimiter", string, index))
try:
nextchar = string[index]
if nextchar in Tool.WhiteSpace:
index += 1
nextchar = string[index]
if nextchar in Tool.WhiteSpace:
index = Tool.escape_whitespace(string, index + 1)
nextchar = string[index]
except IndexError:
nextchar = ''
index += 1
if nextchar != '"':
raise ValueError(Tool.errmsg("Expecting property name", string, index))
values = dict(values)
return values, index
class TBMMSpider:
# 页面初始化
def __init__(self):
self.siteUrl = u'http://mm.taobao.com/json/request_top_list.htm'
self.tool = Tool()
self.user_agent = u'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
# 初始化headers
self.headers = {u'User-Agent': self.user_agent}
# 获取索引页面的内容
def getPage(self,pageIndex):
url = self.siteUrl+u'?page='+str(pageIndex)
print(url)
request = urllib2.Request(url,headers = self.headers)
response = urllib2.urlopen(request)
return response.read().decode(u'gbk')
# 获取索引页面所有MM的信息，list格式
def getContents(self,pageIndex):
page = self.getPage(pageIndex)
patter = re.compile(u'<div class="list-item.*?pic-word.*?<a href="(.*?)".*?<img src="(.*?)" .*?<a class="lady-name.*?>(.*?)</a>.*?<strong>(.*?)</strong>.*?<span>(.*?)</span>',re.S)
items = re.findall(patter,page)
contents = []
for item in items:
# item[0]是MM详情页，item[1]是MM头像地址，item[2]是MM姓名，item[3]是MM年龄，item[4]是MM居住地
# print u'http:'+item[0],u'http:'+item[1],item[2],item[3],item[4]
contents.append([u'http:'+item[0],u'http:'+item[1],item[2],item[3],item[4]])
return contents
# 获取MM个人详情页面
def getDetailPage(self,infoUrl):
request = urllib2.Request(infoUrl,headers=self.headers)
response = urllib2.urlopen(request)
return response.read().decode(u'gbk')
# 获取个人文字简介
def getBrief(self,page):
patter = re.compile(u'<div class="mm-aixiu-content".*?>(.*?)<!--',re.S)
result = re.search(patter,page)
if result:
return self.tool.replaceHTMLTag(result.group(1))
else:
return None
# 获取页面所有图片
def getAllImg(self,page):
patter = re.compile(u'<div class="mm-aixiu-content".*?>(.*?)<!--',re.S)
# 个人信息页面所有代码
content = re.search(patter,page)
# 从代码中提取图片
patterImg = re.compile(u'<img.*?src="(.*?)".*?>',re.S)
print(content)
if content:
images = re.findall(patterImg,content.group(1))
return images
else:
return None
# 保存多张写真图片
def saveImgs(self,images,name):
number = 1
print(u'发现'+name+u'共有'+len(images)+u'张照片')
for imageUrl in images:
splitPath = imageUrl.split(u'.')
fTail = splitPath.pop()
if len(fTail)>3:
fTail = 'jpg'
fileName = name+u'/'+str(number)+u'.'+fTail
self.saveImg(imageUrl,fileName)
number+=1
# 保存头像
def saveIcon(self,iconURL,name):
splitPath = iconURL.split(u'.')
fTail = splitPath.pop()
fileName = name+u'/icon.'+fTail
self.saveImg(iconURL,fileName)
# 写入图片【传入图片地址，文件名，保存单张图片】
def saveImg(self,imgUrl,fileName):
u = urllib.urlopen(imgUrl)
data = u.read()
f = open(fileName,u'wb')
f.write(data)
f.flush()
f.close()
# 写入文本
def saveBrief(self,content,name):
fileName = name+u'/'+name+u'.txt'
f = open(fileName,u'w+')
print(u'正在偷偷保存她的个人信息为'+fileName)
f.write(content.encode('utf-8'))
f.flush()
f.close()
# 创建新目录
def mkdir(self,path):
path = path.strip()
# 判断路径是否存在，存在为True，不存在为False
isExist = os.path.exists(path)
# 判断结果
if not isExist:
# 如果不存在则创建目录
# 创建目录操作函数
os.makedirs(path)
return True
else:
# 如果目录存在则不创建，并提示目录已存在
return False
def savePageInfo(self,pageIndex):
contents = self.getContents(pageIndex)
for item in contents:
print u'发现一位模特，名字叫',item[2],u'，芳龄',item[3],u'，她在',item[4]
print u'正在偷偷地保存',item[2],u'的信息'
print u'又意外地发现她的个人地址是',item[0]
# 个人详情页面的URL
detailURL = item[0]
print(detailURL)
# 得到个人详情页面代码
detailPage = self.getDetailPage(detailURL)
# 获取个人简介
brief = self.getBrief(detailPage)
self.mkdir(item[2])
# 判断个人简介是否为空
if brief:
print(brief)
# 保存个人简介
self.saveBrief(brief,item[2])
# 获取所有图片列表
images = self.getAllImg(detailPage)
print(len(images))
# 保存图片
self.saveImgs(images,item[2])
# 保存头像
self.saveIcon(item[1],item[2])
def savePagesInfo(self,start,end):
for i in range(start,end+1):
print u'正在偷偷寻找第',i,u'个地方，看看MM们在不在'
self.savePageInfo(i)
def __init__(self):
self.siteUrl = u'http://mm.taobao.com/json/request_top_list.htm'
self.tool = Tool()
self.user_agent = u'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
# 初始化headers
self.headers = {u'User-Agent': self.user_agent}
def cfg_listen4(self, nameport): np = Tool.hostport(nameport, Defaults.PORT) self.port.add(socket.AF_INET, np)
#!/usr/bin/env python
import Tool
from knox import Knox
import cPickle
# Load homicides from 2012
d1 = Tool.load_data_from_db(\
'SELECT x, y, ts FROM crime.crimes '+\
'WHERE year=2012 AND ptype=%s', \
'tplagge', 'tplagge', 'dssgpg',select_args=('HOMICIDE',))
# Load graffiti reports from 2012
d2 = Tool.load_data_from_db(\
'SELECT x, y, casedate FROM threeoneone.graffiti '+\
'WHERE extract(Year from casedate)=%s', \
'tplagge','tplagge','dssgpg',select_args=(2012,))
# Extract x, y, time
x1, y1, t1 = d1['x'], d1['y'], d1['ts']
x2, y2, t2 = d2['x'], d2['y'], d2['casedate']
# Run the Knox test with characteristic distance = 1/8 mile
# and characteristic time = 7 day
k = Knox(x1, y1, t1, x2, y2, t2)
X,randdist = k.compute_test_statistic(5280.0/8.0,7.0)
print X
# Save the output to a pickle file
#with open('knox_example.pkl','wb') as f:
# cPickle.dump(X, f)
# cPickle.dump(randdist, f)
