def __init__(self, x, y):
super(ExtraLife, self).__init__()
tempTransform = Transform(rotation=0,
speed=0,
rotationSpeed=0,
x=x,
y=y)
self.obj = mgr.Managers.getInstance().objects.Instantiate(
"ExtraLife", transform=tempTransform)
self.shipThatCollected = None
def printExtremeState(initialState, finalState):
print("Start State : ")
startState = Transform().convertStringToEightPuzzle(
initialState.puzzleState)
for i in range(3):
for j in range(3):
if startState[i][j] == 0:
print("B", end=" ")
else:
print("T" + str(startState[i][j]), end=" ")
print()
print("Goal State : ")
goalState = Transform().convertStringToEightPuzzle(finalState.puzzleState)
for i in range(3):
for j in range(3):
if goalState[i][j] == 0:
print("B", end=" ")
else:
print("T" + str(goalState[i][j]), end=" ")
print()
def getAllSuccessor(self):
x = [1, -1, 0, 0]
y = [0, -0, 1, -1]
puzzleMatrix = Transform().convertStringToEightPuzzle(self.puzzleState)
for i in range(3):
for j in range(3):
if puzzleMatrix[i][j] == 0:
blankX = i
blankY = j
break
successorState = []
for (xMove, yMove) in zip(x, y):
if 0 <= blankX + xMove < 3 and 0 <= blankY + yMove < 3:
successorPuzzleMat = deepcopy(puzzleMatrix)
temp = successorPuzzleMat[blankX + xMove][blankY + yMove]
successorPuzzleMat[blankX + xMove][blankY + yMove] = 0
successorPuzzleMat[blankX][blankY] = temp
successorState.append(
Transform().convertEightPuzzleToString(successorPuzzleMat))
return successorState
def __init__(self, name='obj'):
self.id = GameObject.globalId
GameObject.globalId += 2
self.name = name
self.isActive = True
self.components = []
self.path = None
self.takesPartInAnimCalcs = True
self.add_component(Transform())
def tilesDisplacedHeuristic(self, state):
transform = Transform()
currentPuzzleState = transform.convertStringToEightPuzzle(state)
goalPuzzleState = transform.convertStringToEightPuzzle(
self.goalState.puzzleState)
h = 0
for i in range(3):
for j in range(3):
if currentPuzzleState[i][j] != goalPuzzleState[i][j]:
h += 1
if currentPuzzleState[i][j] == 0 and currentPuzzleState[i][
j] != goalPuzzleState[i][j] and isTileInclude == False:
h -= 1
return h
def applyTransforms(self):
""" Use the objects translation/rotation/scaling values to generate a new transformation Matrix if changes have happened. """
# generate new transformation matrix if needed
if self.oldscaling != self.scaling or self.oldrot != self.rotation or self.oldpos != self.position:
self.transform = Transform()
self.transform.applyScaling(self.scaling)
self.transform.applyRotation(self.rotation)
self.transform.applyTranslation(self.position)
self.oldpos = self.position.copy()
self.oldrot = self.rotation.copy()
self.oldscaling = self.scaling.copy()
self.rearangeContents()
def __init__(self, x, y):
super(FireRateSpeedUp, self).__init__()
tempTransform = Transform(rotation=0,
speed=0,
rotationSpeed=0,
x=x,
y=y)
self.obj = mgr.Managers.getInstance().objects.Instantiate(
"FireRateSpeedUp", transform=tempTransform)
self.expirationTime = None
self.shipThatCollected = None
self.collected = False
self.durationTime = 30
self.fireRateMultiplier = 2
def applyGlobalTransform(self, tr):
st = self.getState()
st['scale'] = st['size']
st = Transform(st)
#trans = QtGui.QTransform()
#trans.translate(*translate)
#trans.rotate(-rotate)
#x2, y2 = trans.map(*st['pos'])
#self.setAngle(st['angle']+rotate*np.pi/180.)
#self.setPos([x2, y2])
st = (st * tr).saveState()
st['size'] = st['scale']
self.setState(st)
def __init__(self, yml=None, variables=None, switch_expect=None):
if yml is not None:
self.__variables = variables
self.__variables.set_vars(yml.get('vars', []))
self.__opts = Opts(yml.get('opts', []), variables)
self.__set_input(yml['input'])
self.__transform = Transform(
yml.get('transform', ''), variables,
self.__opts.get('delimiter', None))
self.__query = yml.get('query', '')
self.__preview = yml.get('preview', '')
self.__bind = Bind(yml.get('bind', {}), self.__variables, self.__transform)
self.__output = Output(yml.get('output', {}), variables)
self.__switch_expect = switch_expect
def printOptimalPath(state, depth, puzzleStateMapWithItsParent):
if state is None:
return depth
else:
totalState = printOptimalPath(puzzleStateMapWithItsParent[state],
depth + 1, puzzleStateMapWithItsParent)
eightPuzzleConfiguration = Transform().convertStringToEightPuzzle(
state)
for i in range(3):
for j in range(3):
if eightPuzzleConfiguration[i][j] == 0:
print("B", end=" ")
else:
print("T" + str(eightPuzzleConfiguration[i][j]), end=" ")
print()
print("###########################")
return totalState
class Driver:
if __name__ == '__main__':
# Extracting data from 5 excel files
extract = Extract()
ds,d,os,sa,ea= extract.getAllData()
# Transforming data to obtain additional columns
transform = Transform()
ds,d= transform.transformAllData(ds,d)
# Dropping unnecessary columns
dropColumns = DropColumns()
drivingSearch,delivery,orders,startAddresses,endAddresses= dropColumns.dropAllColumns(ds,d,os,sa,ea)
# joining the 5 tables
merge=Merge()
finalData = merge.mergeAllTables(drivingSearch,delivery,orders,startAddresses,endAddresses)
# Converting the date columns from Object type to DateTime
finalData= transform.transformdate(finalData)
sqlload=SQL_Load()
sqlload.loadDataToStaging(finalData)
def __init__(self,
position,
mass=1,
body_count=-1,
color=(1, 1, 1),
ecc=1.0):
self.transform = Transform(pos=position, rot=-1)
self.velocity = 0 * mathutils.Vector(
-0.25 * Universe.dt * self.position +
(Universe.dt / 15) * Transform.random_vector())
self.mass = mass
self.body_count = body_count
self.color = np.array(color, dtype=np.float32)
self.ecc = ecc
if self.body_count < 0:
self.body_count = 150000
# buffer stuff
self.body_positions = np.ndarray((self.body_count, 4),
dtype=np.float32)
self.body_velocities = np.ndarray((self.body_count, 4),
dtype=np.float32)
self.body_colors = np.ndarray((self.body_count, 4), dtype=np.float32)
self.body_positions_vbo = vbo.VBO(data=self.body_positions,
usage=gl.GL_DYNAMIC_DRAW,
target=gl.GL_ARRAY_BUFFER)
self.body_velocities_vbo = vbo.VBO(data=self.body_velocities,
usage=gl.GL_DYNAMIC_DRAW,
target=gl.GL_ARRAY_BUFFER)
self.body_colors_vbo = vbo.VBO(data=self.body_colors,
usage=gl.GL_DYNAMIC_DRAW,
target=gl.GL_ARRAY_BUFFER)
self.body_positions_cl_buffer = None
self.body_velocities_cl_buffer = None
self.body_colors_cl_buffer = None
self.body_positions_vbo.bind()
self.body_velocities_vbo.bind()
self.body_colors_vbo.bind()
self.vertex_array = gl.glGenVertexArrays(1)
def main(
timestamp,
src_logpath_format="/data1/nginxlogs/jhlogs/access_jhlogs.%(yyyymmddhhmm)s"
):
yyyymmddhhmm = time.strftime('%Y%m%d%H%M', time.localtime(timestamp))
yyyymmdd = time.strftime('%Y%m%d', time.localtime(timestamp))
hhmm = time.strftime('%H%M', time.localtime(timestamp))
src_logpath = src_logpath_format % {
"yyyymmddhhmm": yyyymmddhhmm,
"yyyymmdd": yyyymmdd
}
errlog_path = errlog_path_format % {
"yyyymmddhhmm": yyyymmddhhmm,
"yyyymmdd": yyyymmdd,
"hhmm": hhmm
}
transform = Transform()
if src_logpath.endswith(".gz"):
src_logpath_file = gzip.open(src_logpath)
else:
src_logpath_file = open(src_logpath)
for line in src_logpath_file:
try:
for log in transform.transform(line):
datatype = log["jhd_datatype"]
# if datatype == "guaeng":
# print datatype, src_logpath_format
# print log
filename = filename_format % {
"yyyymmdd": yyyymmdd,
"hhmm": hhmm,
"datatype": datatype
}
# print filename
log_line = json.dumps(log)
LogStore(filename, log_line)
except Exception, e:
# import traceback
# print traceback.print_exc()
LogStore(errlog_path, "%s, %s" % (e, line))
def manhattanHeuristic(self, state):
transform = Transform()
currentPuzzleState = transform.convertStringToEightPuzzle(state)
goalPuzzleState = transform.convertStringToEightPuzzle(
self.goalState.puzzleState)
currentCoOrdinate = numpy.arange(18).reshape((9, 2))
for i in range(3):
for j in range(3):
currentCoOrdinate[currentPuzzleState[i][j]][0] = i
currentCoOrdinate[currentPuzzleState[i][j]][1] = j
h = 0
for i in range(3):
for j in range(3):
if goalPuzzleState[i][j] != 0:
h += abs(i - currentCoOrdinate[goalPuzzleState[i][j]][0]) + \
abs(j - currentCoOrdinate[goalPuzzleState[i][j]][1])
if goalPuzzleState[i][j] == 0 and isTileInclude:
h += abs(i - currentCoOrdinate[goalPuzzleState[i][j]][0]) + \
abs(j - currentCoOrdinate[goalPuzzleState[i][j]][1])
return h
def main(timestamp, src_file_format=src_file_format):
transform = Transform()
yyyymmdd = time.strftime('%Y%m%d', time.localtime(timestamp))
yyyymmddhhmm = time.strftime('%Y%m%d%H%M', time.localtime(timestamp))
hhmm = time.strftime('%H%M', time.localtime(timestamp))
src_file = src_file_format % {
"yyyymmdd": yyyymmdd,
"yyyymmddhhmm": yyyymmddhhmm
}
errlog_path = errlog_path_format % {"yyyymmdd": yyyymmdd, "hhmm": hhmm}
with open(src_file) as f:
for line in f:
try:
for item in transform.transform(line):
datatype = item['jhd_datatype']
filename = filename_format % {
"yyyymmdd": yyyymmdd,
"hhmm": hhmm,
'datatype': datatype
}
line_out = json.dumps(item, ensure_ascii=False)
LogStore(filename, line_out)
except Exception, e:
LogStore(errlog_path, "%s, %s" % (e, line))
userHdfs = sys.argv[4]
dirHdfs = sys.argv[5]
filename = sys.argv[6]
scriptPath = sys.argv[7]
metadataKey = sys.argv[8]
# Настройка логгирования
logging.basicConfig(
level=logging.INFO,
# filename='myapp.log',
# filemode='w',
format='%(asctime)s %(name)s %(levelname)s:%(message)s')
loaderHandler = Loader(
LoadOption.Create(connectionString=connectionString, query=query))
transformHandler = Transform(TransformOption.Create(scriptpath=scriptPath))
writerHandler = Writer(
WriteOption.Create(webHdfsUrl=webHdfsUrl,
userHdfs=userHdfs,
dirHdfs=dirHdfs,
filename=filename,
metadataKey=metadataKey))
loaderHandler\
.SetNext(transformHandler)\
.SetNext(writerHandler)
loaderHandler.Handle(ProcessMessage.Create())
train = df.iloc[0:trainRows - 1]
test = df
start = trainRows
return train, test, start
df_train, df_test, start = splitTimeData(df, 0.18)
'''
standard transformations
'''
from Transform import Transform as Transform
cols = ['CPI', 'FF', 'IP', 'emp', 'unemp']
t1 = Transform('log', ['IP', 'emp']) # not FF, nor the unemp
o = {'diffs': {'unemp': 0, 'IP': 1, 'emp': 1, 'FF': 1}}
t2 = Transform('diff', cols, o)
t3 = Transform('standardize', cols)
# t3 = Transform('normalize', cols)
transfs = [t1, t2, t3]
'''
standard scorefuns
'''
def RMSE(y_hat, y):
start = y_hat.first_valid_index()
class GetPrecoMedio(Resource):
def get(self):
conn = sqlite3.connect('CaseItau.sqlite3')
cursor = conn.cursor()
neighbourhood_group = request.args.get('neighbourhood_group')
df = pd.read_sql_query(
"SELECT * FROM media_preco WHERE neighbourhood_group =?",
conn,
params=[neighbourhood_group])
conn.commit()
conn.close()
return Response(df.to_json(orient="records"),
mimetype='application/json')
if __name__ == '__main__':
pathresidenci_git, pathmediapreco_git = Transform(
r"https://raw.githubusercontent.com/KaiquePedronio/CaseItau"
r"/master/bases/airbnb_ny_2019.csv",
r"https://raw.githubusercontent.com/KaiquePedronio/CaseItau/master"
r"/bases/mapeamento_vizinhanca.csv").transform()
conn, cursor = Dbase(pathresidenci_git, pathmediapreco_git).Main()
port = int(os.environ.get("PORT", 3000))
app.run(host="127.0.0.1", ssl_context='adhoc', port=port, debug=True)
14, 17, 17, 19, 18, 10, 12, 8, 8, 18, 7, 5, 12, 10, 17, 19, 1, 19, 15, 12,
14, 11, 2, 18, 9, 19, 5, 19, 19, 19, 5, 19, 18, 14, 5, 19, 19, 12, 8, 1, 5,
9, 19, 1, 5, 19, 19, 11, 9, 9, 9, 9, 9, 9, 17, 5, 19, 13, 16, 9, 9, 9, 5,
19, 1, 19, 10, 16, 16, 11, 1, 19, 2, 9, 8, 19, 1, 12, 12, 1, 1, 13, 9, 13,
13, 13, 13, 5, 5, 18, 18, 18, 12, 1, 2, 19, 3, 17, 17, 3, 3, 2, 3, 3, 17,
2, 5, 5, 18, 18, 19, 5, 13, 8, 12, 13, 1, 8, 16, 17, 18, 5, 5, 16, 8, 19,
5, 12, 19, 16, 5, 19, 2, 19, 8, 18, 19, 9, 19, 5, 1, 19, 9, 12, 16, 9, 12,
19, 5, 19, 14, 16, 5, 5, 14, 14, 10, 10, 12, 2, 8, 2, 9, 5, 5, 12, 1, 18,
19, 1, 6, 8, 2, 8, 19, 10, 19, 7, 19, 16, 2, 5, 5, 16, 18, 5, 1, 19, 6, 5,
10, 19, 8, 5, 18, 18, 3, 19, 19, 13, 1, 5, 2, 9, 9, 8, 2, 1, 5, 1, 13, 19,
12, 19, 14, 2, 19, 13, 19, 1, 16, 18, 18, 4, 2, 2, 17, 17, 13, 2, 2, 2, 14,
2, 14, 14, 1, 8, 8, 10, 14, 14, 6, 2, 17, 2, 14, 17, 14, 2, 9
]
make_userdata(array)
#trans = Transform(array, beer_group,14)
trans = Transform(array, beer_group, 400)
trans.transform()
#print("###user_group rating table###")
#print(trans.user_group)
collab = Collaborative(trans.user_group)
#print(collab.getRecommendation(0))
group = Group(beer_group, array)
#print(group.user_group(0,2,True))
#print(group.user_group(12,collab.getRecommendation(12)[0],True)[:8])
def get_recommendation_list(uid):
arr = collab.getRecommendation(uid)
grp1 = arr[0]
grp2 = arr[1]
if __name__ == '__main__':
batch_size = 256
nb_samples = 8000
#path = '/data/xuwenshen/ai_challenge/data/test/ibm_test_b-30.h5py'
path = '/data/xuwenshen/ai_challenge/data/valid/valid/ibm_valid-50-60.h5py'
test_folder = Folder(filepath=path, is_test=True, nb_samples=nb_samples)
test_loader = DataLoader(test_folder,
batch_size=batch_size,
num_workers=1,
shuffle=False)
en_voc_path = '/data/xuwenshen/ai_challenge/data/train/train/en_voc.json'
zh_voc_path = '/data/xuwenshen/ai_challenge/data/train/train/zh_voc.json'
transform = Transform(en_voc_path=en_voc_path, zh_voc_path=zh_voc_path)
en_dims = 712
en_hidden = 900
zh_hidden = 1800
zh_dims = 712
input_dropout_p = 0.5
dropout_p = 0.5
enc_layers = 2
dec_layers = 2
en_max_len = 50
zh_max_len = 60
beam_size = 5
net = Seq2Seq(en_dims=en_dims,
zh_dims=zh_dims,
def __init__(self, **argd):
"""x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
super(OpenGLDisplay, self).__init__()
self.caption = argd.get("title", "http://kamaelia.sourceforge.net")
self.width = argd.get("width", 800)
self.height = argd.get("height", 600)
self.background_colour = argd.get("background_colour", (255, 255, 255))
self.fullscreen = pygame.FULLSCREEN * argd.get("fullscreen", 0)
self.show_fps = argd.get("show_fps", True)
self.limit_fps = argd.get("limit_fps", 0)
self.fps_delay = 0.0
# for framerate limitation
self.clock = pygame.time.Clock()
# 3D component handling
self.ogl_objects = []
self.ogl_names = {}
self.ogl_sizes = {}
self.ogl_displaylists = {}
self.ogl_transforms = {}
self.ogl_nextName = 1
# Eventspies (receive events of other components)
self.eventspies = []
# pygame component handling
self.pygame_surfaces = []
self.pygame_objectid_to_surface = {}
self.pygame_sizes = {}
self.pygame_positions = {}
self.pygame_pow2surfaces = {}
self.pygame_texnames = {}
# used for surface positioning
self.next_position = (0, 0)
# pygame wrapping
self.wrappedsurfaces = []
self.wrapper_requestcomms = {}
self.pending_wrapperrequests = {}
# Event handling
self.eventcomms = {}
self.eventservices = {}
self.eventswanted = {}
self.hitall = argd.get("hitall", False)
# determine projection parameters
self.nearPlaneDist = argd.get("near", 1.0)
self.farPlaneDist = argd.get("far", 100.0)
self.perspectiveAngle = argd.get("perspective", 45.0)
self.aspectRatio = float(self.width) / float(self.height)
global pi
self.farPlaneHeight = self.farPlaneDist * 2.0 / tan(
pi / 2.0 - self.perspectiveAngle * pi / 360.0)
self.farPlaneWidth = self.farPlaneHeight * self.aspectRatio
self.farPlaneScaling = self.farPlaneWidth / self.width
# determine viewer position and orientation
self.viewerposition = Vector(*argd.get("viewerposition", (0, 0, 0)))
self.lookat = Vector(*argd.get("lookat", (0, 0, -self.farPlaneDist)))
self.up = Vector(*argd.get("up", (0, 1, 0)))
# transform used to correct the mouse click positions
self.coordCorrectionTransform = Transform()
self.coordCorrectionTransform.setLookAtRotation(
-self.viewerposition, self.lookat, self.up)
# initialize the display
pygame.init()
display = pygame.display.set_mode(
(self.width, self.height),
self.fullscreen | pygame.DOUBLEBUF | pygame.OPENGL)
pygame.display.set_caption(self.caption)
pygame.mixer.quit()
glClearColor(self.background_colour[0], self.background_colour[1],
self.background_colour[2], 1)
glClearDepth(1.0)
glEnable(GL_DEPTH_TEST)
glDepthFunc(GL_LEQUAL)
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST)
# make fog settings if enabled
fog_dists = argd.get("fog", None)
if fog_dists is not None:
glEnable(GL_FOG)
glFog(GL_FOG_MODE, GL_LINEAR)
glHint(GL_FOG_HINT, GL_NICEST)
glFog(GL_FOG_START, fog_dists[0])
glFog(GL_FOG_END, fog_dists[1])
glFog(GL_FOG_DENSITY, argd.get("fog_density", 1.0))
fog_colour = argd.get("fog_colour", (255, 255, 255))
fog_colour = [float(x) / 255.0 for x in fog_colour]
glFog(GL_FOG_COLOR, fog_colour)
# set projection matrix
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
self.setProjection()
from Transform import Transform
if __name__ == '__main__':
transformObj = Transform('api', 'Pollution')
transformObj
Log = X.loc[X.VP < 1900].copy()
X.drop(Log.loc[Log.Y == 1].index, axis=0, inplace=True)
X.VP = X.VP + np.random.normal(0, X.VP.std(), X.shape[0])
X.VS = X.VS + np.random.normal(0, X.VS.std(), X.shape[0])
X.RHO = X.RHO + np.random.normal(0, X.RHO.std(), X.shape[0])
Xt = pd.read_csv('AVAIMP.txt', sep=';')
Xt = Xt[cols]
#Log=Xt.loc[Xt.VP < 1900 ].copy()
#Xt.drop(Log.loc[Log.Y==1].index,axis=0,inplace=True)
Xt = Test
X = X.sample(frac=1)
y = X.Y
yt = Xt.Y
T = Transform()
T.transform(X)
T.transform(Xt)
columns = ['RHO', 'VP', 'VS', 'K', 'Zp', 'Zs', 'u', 'Lame']
X = X[columns]
Xt = Xt[columns]
#Xt=pd.read_csv('NUOVOTEST.txt', sep=';')
#cols2=['Z','RHO','VP','VS','PIGE','SW','SH','Y']
#Xt.columns=cols2
#Xt=Xt[cols2]
#colors = ["pale red", "denim blue", "medium green"]
#
#Xt2=pd.read_csv('Avares.txt', sep=';')
#Xt2.columns=cols
#Xt2.RHO=Xt2.RHO/1000
from flask import Flask
from flask import jsonify
import json
from Transform import Transform
app = Flask("flask")
transform = Transform()
@app.route("/")
def route():
return {"villeChoisie": "Montreal"}
@app.route('/extracted_data')
def show_extracted_data():
nbRestaurants = transform.get_nbRestaurants()
nbSegments = transform.get_nbSegments()
extracted_data = {}
extracted_data['nbRestaurants'] = nbRestaurants['nbRestaurants']
extracted_data['nbSegments'] = nbSegments
return extracted_data
@app.route('/transformed_data')
def show_transformed_data():
nbRestaurants_type = transform.get_nbRestaurants_type()
longueurCyclable = transform.get_longueurCyclable()
test = df #df.ix[trainRows:rows+1]
start = trainRows
return train, test, start
df_train, df_test, start = splitTimeData(df, 0.18)
'''
standard transformations
'''
from Transform import Transform as Transform
cols = ['IP', 'GDP', 'emp', 'CPI', 'FF']
# not FF, GDP or unemp
t1 = Transform('log', ['IP', 'emp', 'CPI'])
o = {
'diffs': {
'IP': 1,
'GDP': 0,
'emp': 1,
'CPI': 2,
'FF': 1
}
}
t2 = Transform('diff', cols, o)
t3 = Transform('standardize', cols)
# t3 = Transform('normalize', cols)
from Capture import Capture from Edge import Edge from Transform import Transform from Threshold import Threshold from PDF import pdf from pis import four_point_transform import numpy as np import rect import cv2 import imutils list = Capture() print list Edge(list) Transform(list) Threshold(list) pdf(list)
import numpy as np
import torch
from torch import nn
from torch import autograd
from torch.autograd import Variable
import json
import random
import torch.nn.utils.rnn as rnn_utils
from Transform import Transform
from Transform import Transform
transform = Transform(
zh_voc_path='/data/xuwenshen/ai_challenge/data/train/train/zh_voc.json',
en_voc_path='/data/xuwenshen/ai_challenge/data/train/train/en_voc.json')
weight = [1 for i in range(len(transform.zh_voc))]
weight[transform.zh_pad_id] = 0
class EncCNN(nn.Module):
def __init__(self, dropout_p, channels, kernel_size, en_dims, en_max_len):
super(EncCNN, self).__init__()
self.conv = nn.Conv1d(in_channels=en_dims,
out_channels=channels,
kernel_size=kernel_size,
padding=1)
def __init__(self):
self.transform = Transform()
self.project = Projection()
self.norm = Normalization()
def createRadialTree(self, fanout, depth, spread, isRoot=False):
if depth <= 0:
return None
# * Create this node (an actor)
treeNode = Actor(self.actor.renderer, isTransient=True)
# * Attach children if depth > 1
if depth > 1:
if isRoot:
# ** Pick all random directions first, to ensure a good spread, and then generate children
childVectors = np.float32(
[[-1, -1, -1], [1, -1, -1], [1, 1, -1], [-1, 1, -1],
[-1, -1, 1], [1, -1, 1],
[1, 1, 1], [-1, 1, 1]]
) # NOTE these canonical directions are same as cube vertices!
# ** Perturb child vectors, and compute unit direction vectors
perturbation = np.random.normal(scale=1.0,
size=childVectors.shape)
#print "RadialTree.__init__(): Child:-\norig. vectors:\n", childVectors, "\nperturbation :\n", perturbation
childVectors += perturbation
#print "pert. vectors:\n", childVectors
childNorms = np.apply_along_axis(
lambda vec: np.linalg.norm(vec, ord=2), 1, childVectors)
#print "child norms:\n", childNorms
childUnits = childVectors / childNorms[:, np.newaxis]
# ** Use child unit vectors one by one to create fanout first-level children
numChildren = fanout if fanout <= childUnits.shape[
0] else childUnits.shape[
0] # NOTE assert/enforce: actual fanout <= childUnits.shape[0]
# TODO randomly pick from child unit vectors without replacement?
for unit in childUnits[0:numChildren]:
translation = self.treeEdgeLength * unit
phi = np.arctan2(-unit[2], unit[0])
theta = np.arcsin(unit[1])
rotation = np.degrees(
np.float32([0, phi, theta])
) # NOTE random X-axis rotation can be added (but won't make any difference): np.random.uniform(-pi, pi)
#print "RadialTree.__init__(): Child:-\nunit:", unit, "[ norm = ", np.linalg.norm(unit, ord=2), "]\ntranslation:", translation, "\nrotation:", rotation
childNode = self.createRadialTree(
np.random.random_integers(3, 4), depth - 1,
spread) # recurse down, decreasing depth
childNode.components['Transform'] = Transform(
translation=translation,
rotation=rotation,
actor=childNode
) # NOTE scaling will accumulate, so use scale = 1 (default)
childNode.components['Material'] = Material(
color=self.edgeColor, actor=childNode)
childNode.components['Mesh'] = Mesh.getMesh(
src=self.treeEdgeModelFile, actor=childNode)
treeNode.children.append(childNode)
else:
while len(treeNode.children) < fanout:
# ** Pick a random direction for creating a new child
spread_rad = np.radians(spread)
phi = np.random.uniform(
-spread_rad, spread_rad) # rotation around Y axis
theta = np.random.uniform(
-spread_rad, spread_rad) # rotation around Z axis
rotation = np.degrees(np.float32([
0.0, phi, theta
])) # this will serve as orientation for the tree edge
# TODO pick a random length; scale X axis accordingly (how? flatten tree hierarchy? pick from discrete lengths and use different models accordingly?)
# ** Compute relative position of new child (in cartesian coordinates) and normalized unit vector
translation = np.float32([
self.treeEdgeLength * cos(theta) * cos(phi),
self.treeEdgeLength * sin(theta),
-self.treeEdgeLength * cos(theta) * sin(phi)
])
norm = np.linalg.norm(translation, ord=2)
unit = translation / norm
# TODO check closeness condition (too close to existing nodes? parent? - need absolute coordinates for that!)
# ** Generate and add child (with nested tree)
childNode = self.createRadialTree(
np.random.random_integers(3, 4), depth - 1,
spread) # recurse down, decreasing depth
childNode.components['Transform'] = Transform(
translation=translation,
rotation=rotation,
actor=childNode
) # NOTE scaling will accumulate, so use scale = 1 (default)
childNode.components['Material'] = Material(
color=self.edgeColor, actor=childNode)
childNode.components['Mesh'] = Mesh.getMesh(
src=self.treeEdgeModelFile, actor=childNode)
treeNode.children.append(childNode)
return treeNode
def __init__(self, scale=cube_scale, actor=None):
Component.__init__(self, actor)
Trackable.__init__(self)
self.scale = scale
# Scale vertices of base cube, specify edges, and initialize list of markers
self.vertices = cube_vertices * self.scale
self.vertex_colors = cube_vertex_colors
self.vertex_scale = 0.3 * self.scale # NOTE for rendering only, depends on 3D model
self.edges = cube_edges
self.edge_scale = 0.1 * self.scale # NOTE for rendering only, depends on 3D model
self.edge_color = np.float32([0.8, 0.7,
0.5]) # NOTE for rendering only
# TODO make some of these parameters come from XML
# NOTE Mark generated child actors (corners and edges) as transient, to prevent them from being exported in XML
# Add spheres at cube corners (vertices) with appropriate color; also add color markers
for vertex, colorName in zip(self.vertices, self.vertex_colors):
vertexActor = Actor(self.actor.renderer, isTransient=True)
vertexActor.components['Transform'] = Transform(
translation=vertex, scale=self.vertex_scale, actor=vertexActor)
vertexActor.components['Material'] = Material(
color=colors_by_name[colorName], actor=vertexActor)
vertexActor.components['Mesh'] = Mesh.getMesh(
src="SmallSphere.obj", actor=vertexActor)
self.actor.children.append(vertexActor)
marker = ColorMarker(self, colorName)
marker.worldPos = vertex
self.markers.append(marker)
# Add edges
for u, v in self.edges:
if u < len(self.vertices) and v < len(
self.vertices
) and self.vertices[u] is not None and self.vertices[
v] is not None: # sanity check
midPoint = (self.vertices[u] + self.vertices[v]) / 2.0
diff = self.vertices[v] - self.vertices[u]
mag = np.linalg.norm(diff, ord=2)
xy_mag = hypot(diff[0], diff[1])
#zx_mag = hypot(diff[2], diff[0])
rotation = np.degrees(
np.float32([
atan2(diff[1], diff[0]),
acos(diff[1] / mag), 0
])) if (mag != 0 and xy_mag != 0) else np.float32(
[0.0, 0.0, 0.0])
#print "u: ", self.vertices[u], ", v: ", self.vertices[v], ", v-u: ", diff, ", mag: ", mag, ", rot:", rotation
edgeActor = Actor(self.actor.renderer, isTransient=True)
edgeActor.components['Transform'] = Transform(
translation=midPoint,
rotation=rotation,
scale=self.edge_scale,
actor=edgeActor)
edgeActor.components['Material'] = Material(
color=self.edge_color, actor=edgeActor)
edgeActor.components['Mesh'] = Mesh.getMesh(
src="CubeEdge.obj", actor=edgeActor
) # TODO fix Z-fighting issue and use CubeEdge_cylinder.obj
self.actor.children.append(edgeActor)
