def fkChain(cls, joints):
# given some joints, creates a very primitive FK chain
# returns list of controls for chain as Control instances
if not isinstance(joints, list):
err = "Couldn't create a chain with {0} because it's not a list."
raise RuntimeError(err.format(joints))
return
joints = [j for j in joints if cmds.nodeType(j) == 'joint']
cons = []
par = None
for j in joints:
con = control.Control(name=j, align_to=j)
con.create()
if par is not None:
con.setParent(par.getName())
con.drive_parented(j)
cons.append(con)
par = con
return cons
def main():
conf = getConf()
ch = conf['change']
ad = conf['insert']
re = conf['remove']
ma = conf['acceptableMatchDgree']
topres = conf['topres']
target = input("the phrase : ")
print('Enter the subs folder or press Enter\nTo use the current directory:\n\
{}'.format(os.getcwd()))
path = input('Path/Entre : ')
if len(path) == 0:
path = None
else:
if path[0] == '~':
path = os.path.expanduser(path)
if not os.path.isdir(path):
print('directory not found')
quit
print('please hold ...')
res = control.Control(target,path,change = ch,remove = re,insert=ad,matchdegree = ma)
mat = min(topres,len(res.res))
print(f'here are the top {mat} matches')
while mat:
mat-=1
print(res.res.pop())
def __init__(self,
prefix='new',
suffix='_ctl',
scale=1.0,
curveShape='squareZ',
attachTrans=''):
self.unit = mc.group(n=prefix + 'Unit_grp', em=1)
self.hide = mc.group(n=prefix + 'Hide_grp', em=1)
self.noTouch = mc.group(n=prefix + 'NoTouch_grp', em=1)
self.joints = mc.group(n=prefix + 'Joints_grp', em=1)
self.prefix = prefix
self.unitControl = control.Control(prefix=self.prefix + 'Unit',
colorIdx='',
curveShape=curveShape,
suffix=suffix)
if attachTrans:
mc.delete(mc.parentConstraint(attachTrans, self.unitControl.off))
mc.parent(self.noTouch, self.joints, self.hide)
mc.parent(self.hide, self.unitControl.c)
mc.parent(self.unitControl.off, self.unit)
mc.hide(self.hide)
mc.setAttr(self.noTouch + '.it', 0)
def startControl(sysVar):
threadControl = control.Control(sysVar)
sysVar.threadControl = threadControl
threadControl.setDaemon(True)
threadControl.setName("control egg force one")
threadControl.start()
pass
def setup(self, send, log, cfg, botopts):
BotMod.setup(self, send, log, cfg, botopts)
def_cfg = {
'chime_start_sound': 'sounds/prompt.wav',
'chime_stop_sound': 'sounds/finish.wav',
'play_start_cmd': '',
'play_stop_cmd': '',
'chime_start_cmd': 'play %s',
'chime_stop_cmd': 'play %s',
'start_stream_cmd': 'tools/stream_ssh %s',
'stop_stream_cmd': '',
'play_chimes': True,
'start_muted': False
}
cfg = cfg.get_section('player', def_cfg)
self.log("player_cfg:", cfg)
self.worker = worker.Worker()
self.worker.set_chime_sound('start', cfg['chime_start_sound'])
self.worker.set_chime_sound('stop', cfg['chime_stop_sound'])
self.worker.set_command('play_start', cfg['play_start_cmd'])
self.worker.set_command('play_stop', cfg['play_stop_cmd'])
self.worker.set_command('chime_start', cfg['chime_start_cmd'])
self.worker.set_command('chime_stop', cfg['chime_stop_cmd'])
self.worker.set_command('start_stream', cfg['start_stream_cmd'])
self.worker.set_command('stop_stream', cfg['stop_stream_cmd'])
self.worker.set_play_chimes(cfg['play_chimes'])
self.worker.set_callback('state', self._state_cb)
self.worker.set_callback('error', self._error_cb)
self.worker.set_callback('info', self._info_cb)
start_muted = cfg['start_muted']
self.control = control.Control(self, self.send_event, start_muted)
def main():
r_instance.R = Robot()
set_debug_mode(True)
dump_battery()
# Initialise modules
task.pool = task.TaskPool()
control.control = control.Control()
vision.vision = vision.Vision()
arduino_interface.arduino = arduino_interface.Arduino()
game_map.game_map = game_map.Map()
# Move initial token
task.pool.execute(control.MoveTask(1.2))
task.pool.execute(control.MoveTask(-0.6))
tokens = vision.vision.capture()[0]
our_marker_id = 0
if len(tokens) > 0:
our_marker_id = tokens[0].info.code
log("Robot", "our_marker_id = {0}".format(our_marker_id))
task.pool.execute(control.MoveTask(-0.7))
# Look at remaining tokens and move into them
task.pool.execute(control.RotateTask(-math.pi * 0.35))
# Attempt to correct itself
task.pool.execute(TokenCorrection(our_marker_id))
task.pool.execute(control.MoveTask(0.775))
for i in xrange(2):
task.pool.execute(control.RotateTask(math.pi * 0.4, 3.0))
task.pool.execute(control.MoveTask_Stepper(2.0, 3.0, 8))
"""
# Move away, turn 180 degrees then calibrate
task.pool.add( control.MoveTask( -1.5 ) )
task.pool.add( control.RotateTask( -math.pi * 0.5 ) )
task.pool.add( control.MoveTask( 2, 0.75 ) )
# Now we know where we are, move to where our tokens reside and grab one
target_point = game_map.game_map.starting_position
target_point.x = 8 - target_point.x
task.pool.add( FigureOutPosition() )
task.pool.add( MoveToNextPoint( target_point ) )
task.pool.add( SearchForToken() )
task.pool.add( control.RotateTask( -math.pi * 0.5 ) )
task.pool.add( control.MoveTask( 2 ) )
task.pool.add( control.MoveTask( -1 ) )
# Move to the middle square
task.pool.add( FigureOutPosition() )
task.pool.add( MoveToNextPoint( Position( 5, 5 ) ) )
"""
# Enter the main loop
task.pool.execute(task.ExitLoop())
task.pool.run()
# Final words..
log("Robot", "Task queue finished executing, exiting...")
dump_battery()
def main():
switch_config = _get_switch_config()
ctrl = control.Control(
's1', 23000, str(switch_config["simple_router"]["pd_thrift_path"]))
for i in range(10):
print ctrl.get_my_counter(i)
ctrl.close()
def main():
switch_config = _get_switch_config()
ctrl = control.Control(
's1', 23000, str(switch_config["simple_router"]["pd_thrift_path"]))
ret = ctrl.get_flow_radar()
print len(ret)
print ret[:4 * 16 * 7]
ctrl.close()
def main():
switch_config = _get_switch_config()
ctrl = control.Control(
's1', 23000, str(switch_config["simple_router"]["pd_thrift_path"]))
ret = ctrl.get_whole_counting_table()
print len(ret)
print ret
ctrl.close()
def __init__(self, prefix='new'):
# global control
super(GlobalUnit, self).__init__(prefix='superMover',
curveShape='masterAnim')
mc.parent(self.unitControl.c, self.unit)
rigScalePlug = self.unitControl.c + '.global_scale'
mc.addAttr(self.unitControl.c,
ln='global_scale',
at='float',
dv=1,
h=0,
k=1)
for attr in self.unitControl.s:
mc.setAttr(attr, l=0)
mc.connectAttr(rigScalePlug, self.unitControl.c + '.sx')
#scale reciprocal
scaleRecip = node.recipNode(prefix='superMover',
inPlugOne=rigScalePlug)
self.recipPlug = scaleRecip + '.ox'
# groups
self.modelGrp = mc.group(n='model_grp', em=1)
self.deformGrp = mc.group(n='deform_grp', em=1)
mc.parent(self.modelGrp, self.deformGrp, self.unit)
# clean-up
for attr in ['t', 's', 'r']:
mc.setAttr(self.unit + '.' + attr, l=1, cb=0, k=0)
mc.hide(self.deformGrp)
mc.delete(
self.unitControl.c + 'Shape1.cv[0:10]',
self.unitControl.off,
)
self.unit = mc.rename(self.unit, prefix + '_grp')
self.unitControl.c = mc.rename(self.unitControl.c, 'superMover_ctl')
# root control
self.rootControl = control.Control(prefix='root',
colorIdx='',
curveShape='circleY',
scale=0.45)
mc.parent(self.rootControl.off, self.unitControl.c)
def main(args):
main_start_time = time.time()
random.seed(args.seed)
torch.manual_seed(args.seed)
device = torch.device('cuda' if args.cuda else 'cpu')
model_path = args.model if args.model else make_model_path(args)
logger = mylogger.Logger(model_path + '.log', args.train)
logger.log(' '.join(sys.argv) + '\n')
if args.batch_size_valid > 0:
batch_size_valid = args.batch_size_valid
else:
batch_size_valid = 1 if args.batch_method == 'continuous' else 60
dat = data.Data(args.data,
args.batch_size,
args.batch_method,
device,
sort=args.sort,
logger=logger,
is_conditional=args.cond,
batch_size_valid=batch_size_valid)
s2s = model.Seq2Seq(len(dat.i2w),
args.dim,
args.nlayers,
args.dropout,
is_conditional=args.cond,
bidirectional_encoder=args.bidir,
use_bridge=args.bridge,
use_attention=args.attn,
logger=logger).to(device)
ctrl = control.Control(s2s,
args.lr,
args.bptt,
args.interval,
model_path=model_path,
logger=logger)
if args.train:
ctrl.train(dat, args.epochs, args.shuffle)
logger.log(
time.strftime("%H:%M:%S",
time.gmtime(time.time() - main_start_time)))
else:
ctrl.load_s2s()
train_loss, train_sqxent = ctrl.evaluate(dat.train)
valid_loss, valid_sqxent = ctrl.evaluate(dat.valid)
print('train ppl: %.2f train sqxent: %.2f' %
(math.exp(train_loss), train_sqxent))
print('valid ppl: %.2f valid sqxent: %.2f' %
(math.exp(valid_loss), valid_sqxent))
def run_backward(self, distance, desired_colour):
self.reverse = -1
self.start_time = time()
self.marker_counter = 0
pid_controller = control.Control(self.DT)
while not self.shut_down:
self.correct_trajectory(self.csbr, self.csbl, self.rm, self.lm,
pid_controller)
self.count_markings(self.csfr, self.csfl, desired_colour)
if self.marker_counter >= distance:
return
def main():
switch_config = _get_switch_config()
topo = MyTopo(switch_config)
net = Mininet(topo=topo, host=P4Host, switch=P4Switch, controller=None)
net.start()
sw_mac = ["00:aa:bb:00:%02d:%02d" % (i, i) for i in range(1, nh + 1)]
sw_addr = ["10.0.%d.1" % i for i in range(1, nh + 1)]
# There is a command in Mininet to do this, TODO fix
print "Initializaing host stack config"
for n in range(nh):
h = net.get('h%s' % (n + 1))
print "[Host: h%s]" % (n + 1)
h.defaultIntf().rename("eth0")
cmd = "arp -i eth0 -s %s %s" % (sw_addr[n], sw_mac[n])
print cmd
h.cmd(cmd)
cmd = "route add default gw %s" % sw_addr[n]
print cmd
h.cmd(cmd)
for off in ["rx", "tx", "sg"]:
cmd = "/sbin/ethtool --offload eth0 %s off" % off
print cmd
h.cmd(cmd)
print "disable ipv6"
h.cmd("sysctl -w net.ipv6.conf.all.disable_ipv6=1")
h.cmd("sysctl -w net.ipv6.conf.default.disable_ipv6=1")
h.cmd("sysctl -w net.ipv6.conf.lo.disable_ipv6=1")
h.cmd(
"iptables -I OUTPUT -p icmp --icmp-type destination-unreachable -j DROP"
)
sleep(1)
print "Adding table entries"
ctrl = control.Control(
's1', 23000, str(switch_config["simple_router"]["pd_thrift_path"]))
for i in range(1, nh + 1):
ctrl.add_ipv4_lpm_with_set_nhop(0x0a00000a + i * 0x100, 24,
0x0a00000a + i * 0x100, i)
ctrl.add_forward_with_set_dmac(0x0a00000a + i * 0x100,
"00:aa:bb:00:00:%02d" % i)
ctrl.add_send_frame_with_rewrite_mac(i,
"00:aa:bb:00:%02d:%02d" % (i, i))
ctrl.add_flow_radar_default_action()
ctrl.close()
print "Done"
CLI(net)
net.stop()
def __init__(self, planner_out):
# extract data from planner output
self.waypoints = planner_out[0]
self.trajectory = planner_out[1]
# create array of times (every 50ms)
self.numSteps = (self.waypoints[-1].time - self.waypoints[0].time) * 20
# control variable for update loop
self.i = 0
# set up control object
self.control = control.Control(self.waypoints, self.trajectory)
def __init__(self):
# spaces
super(LocalUnit, self).__init__(curveShape='fatCross')
self.globalSpace = control.Control(prefix=self.prefix + 'GlobalSpace',
colorIdx=29,
curveShape='cross')
self.localSpace = control.Control(prefix=self.prefix + 'LocalSpace',
colorIdx=29,
curveShape='cross')
self.bodySpace = control.Control(
prefix=self.prefix + 'BodySpace',
colorIdx=29,
curveShape='cross',
)
self.itemSpace = control.Control(prefix=self.prefix + 'ItemSpace',
colorIdx=29,
curveShape='cross')
mc.parent(self.localSpace.off, self.bodySpace.off,
self.globalSpace.off, self.itemSpace.off, self.unitControl.c)
#visibility
spaceVisPlug = self.unit + '.space_vis'
spaceShapes = [
mc.listRelatives(curve, c=1)[0] for curve in [
self.globalSpace.c, self.localSpace.c, self.bodySpace.c,
self.itemSpace.c, self.unitControl.c
]
]
mc.addAttr(self.unit, ln='space_vis', at='bool', dv=0, h=0, k=1)
for shape in spaceShapes:
mc.connectAttr(spaceVisPlug, shape + '.v')
def __init__(self, **kwargs):
super(LifeGo, self).__init__(**kwargs)
self.controlT = control.Control()
self.ambienteS = ambiente.TemperaturaAmbiente()
self.organoS = organo.TemperaturaOrgano()
self.ambienteS.start()
self.organoS.start()
threading.Thread(target=self.controlT.actualizar,
args=(self.ambienteS, )).start()
self.temperaturaActual = str('no ha iniciado')
self.humedadActual = str('no ha iniciado')
self.temperaturaOrganoActual = str('no ha iniciado')
self.temperaturaDeseada = 4
self.controlT.setPoint(self.temperaturaDeseada)
def __init__(self, cpu_class, gpu_class, ram_class):
self.path = (f"{os.path.dirname(os.path.abspath(__file__))}/")
self.builder = Gtk.Builder()
self.builder.add_from_file(f'{self.path}ui.glade')
self.control = cntrl.Control()
self.builder.connect_signals(
Handler(self, self.control) # connect event signals to MainHandler
)
self.window = self.builder.get_object('application_window')
# Imports the css
style_provider = Gtk.CssProvider()
style_provider.load_from_path(f'{self.path}style.css')
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), style_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
self.cpu_info = cpu_class
self.gpu_info = gpu_class
# INFO
def static_info():
cpu_static_info = cpu_class()
gpu_static_info = gpu_class()
ram_static_info = ram_class()
cpu_labels = {
'cpu_name_label': cpu_static_info.name,
'cpu_cores_threads_label': cpu_static_info.cores_threads
}
gpu_labels = {'gpu_name_label': gpu_static_info.name}
ram_labels = {
'ram_capacity_label': ram_static_info.capacity,
'ram_manufacturer_label': ram_static_info.modules_manufacturer
}
self.update_labels(cpu_labels)
self.update_labels(gpu_labels)
self.update_labels(ram_labels)
static_info()
# CONTROL
self.cntrl_check_button = self.builder.get_object('GpuCheckButton')
self.control_scale = self.builder.get_object('GpuFanScale')
self.control_gpu_adjustment = self.builder.get_object(
'GpuFanAdjustment')
self.threads_run = True
self.control_init()
def __init__(self,
pos,
vel=None,
rot=0,
owner=None,
sprite=None,
size=None,
expiry=EXPIRY_BULLET,
health=100):
self.age = 0
self.expiry = expiry
self.health = health
self.pos = pos
self.rot = rot
self.player = False
self.interact = True
if not vel:
if owner: self.vel = vector.component(SPD_BULLET, owner.rot)
else: self.vel = (SPD_BULLET, 0)
else:
self.vel = vel
self.owner = owner
self.ctlfunc = control.Control(self)
#if not Image.images.has_key("OBJ_BULLET"):
# Image("OBJ_BULLET", IMGDIR + "OBJ_BULLET" + IMGEXT)
#self.image = Image.images["OBJ_BULLET"]
#self.size = (self.image.w, self.image.h)
if not sprite:
self.sprite = sprclass.bullet
else:
self.sprite = sprite
if not size:
self.size = len(self.sprite[0]), len(self.sprite)
else:
self.size = size
self.cells = []
cell.add(self)
Entity.entities.append(self)
def start():
mapsize = 4 # 定义尺寸4*4
MAP = map.Map(mapsize) # 初始化【面板】
MOVE = move.Move(mapsize) # 初始化【移动面板的工具】
CONTROL = control.Control() # 初始化【获取键盘的工具】
# MAP.setTestMap_1() # 自定义初始化，用于测试
MAP.printMap() # 显示初始面板
GAMEOVER = False
while GAMEOVER==False: # 循环主体
dir = CONTROL.getdir() # 获取键盘方向
ISCHANGE = MOVE.movemap(MAP,dir) # 根据方向执行操作，返回【面板】是否有变化
if ISCHANGE: # 如果【面板】有变化
LASTONE = MAP.addone() # 肯定可以添加，返回是不是最后一个空
MAP.printMap() # 打印面板
# 如果填充是最后一个空，则判断是否不能再操作
GAMEOVER = MAP.isend() if LASTONE else False
print('Game over!')
def __init__(self, pos = None, rot = 0, vel = (0, 0), size = None, \
ctlfunc = None, interact = True, player = False, sprite = None, colour = (255, 255, 255), health = 100, owner = None):
self.age = 0
self.expiry = -1
self.health = health
self.owner = owner
self.pos = pos # centre of entity. if this remains None, interact should probably remain False. god help you if it doesn't
self.rot = rot
self.vel = vel
self.sprite = sprite
if not size:
if sprite:
self.size = len(self.sprite[0]), len(self.sprite)
else:
self.size = (0, 0)
else:
self.size = size
if not ctlfunc:
self.ctlfunc = control.Control(self)
else:
self.ctlfunc = ctlfunc
# collision check flag
if not self.pos:
self.interact = False
else:
self.interact = interact
self.player = player
if self.player:
Entity.players.append(self)
self.colour = colour
self.cells = []
if self.interact:
cell.add(self)
Entity.entities.append(self)
def run(self):
self.ctl = control.Control()
self.board = board.Board(10)
p1 = ''
p2 = ''
bsid = ''
as_player = ''
msg = self.sock.recv(1024).decode().split()
if msg[0] == "BATL":
p1 = msg[1]
p2 = msg[2]
bsid = msg[3]
as_player = msg[4]
# register to session
self.sock.send("BTLS {}".format(bsid).encode())
if self.sock.recv(1024).decode() == "GOAWAY":
return 6
ret = self.startbattle(p1, p2)
return ret
def main():
os.environ['SDL_VIDEO_CENTERED'] = '1'
pygame.init()
pygame.mixer.init()
SCREEN_SIZE = (720, 480)
DESIRED_FPS = 60.0
pygame.display.set_mode(SCREEN_SIZE)
pygame.display.set_caption("Bezier")
state_dict = {
# Insert your states here
"main_state": bezier.MainState()
}
game_control = control.Control(1000.0 / DESIRED_FPS)
# Change and uncomment line below, after you complete state_dict
game_control.setup_states(state_dict, "main_state")
game_control.main()
pygame.quit()
sys.exit()
def __init__(self, targets):
window = gtk.Window(gtk.WINDOW_TOPLEVEL) #create window
window.connect("destroy", self.quit)
window.set_title(self.versionString)
window.set_icon(self.getIcon())
self.window = window
self.prefs = prefs.Prefs(self)
self.mplayer = mplayer.Mplayer(self)
self.remote = remote.Remote(self)
self.playlist = playlist.Playlist(self)
self.systray = systray.Systray(self)
self.control = control.Control(self)
self.menu = menu.Menu(self)
vbox = gtk.VBox(False, 0)
vbox.pack_start(self.playlist.scrollview, True, True, 0)
vbox.pack_start(self.control.hbox, False, False, 0)
window.add(vbox) #prepare to start ui
window.show_all()
window.move(self.prefs.getInt("x"), self.prefs.getInt("y"))
window.resize(self.prefs.getInt("width"), self.prefs.getInt("height"))
if targets: #process targets
self.playlist.load(targets)
if self.playlist.continuous: #and begin playback
self.playlist.jump(0)
else: #or load last list
self.playlist.loadm3u()
gtk.main()
Log.verbose = args.verbose
Log.filename = args.log
Log.stdout = not args.quiet
log = Log.Log('main')
# Share statistics module
shares = share_stats.Shares()
# Start proxy cleaner thread
proxies = Proxy.ProxyDB()
t = threading.Thread(target=proxies.cleaner, args=[])
t.daemon = True
t.start()
# Set and start control thread
controller = control.Control(proxydb=proxies, sharestats=shares)
controller.listen_ip = args.control
controller.listen_port = args.control_port
controller.poolmap['pool'] = args.pool
controller.poolmap['port'] = args.port
controller.poolmap['user'] = args.username
controller.poolmap['pass'] = args.password
t = threading.Thread(target=controller.start, args=[])
t.daemon = True
t.start()
# Start listening for incoming connections
server_listen = connection.Server(args.listen, args.listen_port)
while not shutdown:
""" Add Exception Handler! """
""" pyBBIO """
import Adafruit_BBIO.UART as UART
import Adafruit_BBIO.PWM as PWM
import Adafruit_BBIO.ADC as ADC
""" Public python modules """
import serial
import numpy as np
import time
""" DIY Modules (placed in the same dir.)"""
import sensor
import control
""" Instances """
timeSTMP0 = control.Control()
timeSTMP1 = control.Control()
ctrlRoll = control.Control()
ctrlPitch = control.Control()
""" Overlay DTO using pyBBIO """
PWM.start("P9_14", 10.9, 50, 0) # PWM.start(pin, duty, freq, polarity)
PWM.start("P9_16", 9.4, 50, 0) # PWM.start(pin, duty, freq, polarity)
UART.setup("UART1") # IMU
ADC.setup() # ADC
""" Set port and baud rate """
ser = serial.Serial(port="/dev/ttyO1", baudrate=115200)
ser.close()
ser.open()
if ser.isOpen():
""" Position initialization for the static test """
time.sleep(0.5)
mot1_pos = 10.9 # PWM_mot1 with interceptor Stroke 0%
mot2_pos = 9.4 # PWM_mot2 with interceptor Stroke 0%
f = getattr(self.control, 'turn_on')
f()
except Exception as e: # generic error
raise Exception('Error doing turn_on')
def turn_off_handler(self):
try:
f = getattr(self.control, 'turn_off')
f()
except Exception as e: # generic error
raise Exception('Error doing turn_on')
if __name__ == '__main__':
import time
import sys
import control
c = control.Control()
svr = CommandServer(config.RPC_HOST, config.RPC_PORT, c)
server_thread = threading.Thread(target=svr.serve)
server_thread.daemon = True
server_thread.start()
try:
while True:
time.sleep(0.5)
except KeyboardInterrupt:
print 'Finished.'
sys.exit()
def __init__(self, characterName='new', scale=1.0, mainCtrlAttachObj=''):
"""
:param characterName: str, character name
:param scale: float, general scale of the rig
:return None
"""
self.topGrp = cmds.group(n=characterName, em=1)
characterNameAttr = 'characterName'
sceneObjectTypeAttr = 'sceneObjectType'
for attr in [characterNameAttr, sceneObjectTypeAttr]:
cmds.addAttr(self.topGrp, ln=attr, dt='string')
cmds.setAttr(self.topGrp + '.' + characterNameAttr,
characterName,
type='string',
l=1)
cmds.setAttr(self.topGrp + '.' + sceneObjectTypeAttr,
sceneObjectType,
type='string',
l=1)
# make global control
self.Master_Ctrl = control.Control(prefix='C_',
rigPartName='Master',
shape='crownCurve',
scale=scale * 10.0,
parent=self.topGrp,
axis='z',
lockChannels=['v'])
if not cmds.attributeQuery(
'MasterCtrl', node=self.Master_Ctrl.C, exists=1):
cmds.addAttr(self.Master_Ctrl.C, ln='MasterCtrl', at='message')
self.Move_Ctrl = control.Control(prefix='C_',
rigPartName='Move',
shape='moveControl',
scale=scale * 15.0,
parent=self.Master_Ctrl.C,
axis='z',
lockChannels=['s', 'v'])
if not cmds.attributeQuery('MoveCtrl', node=self.Move_Ctrl.C,
exists=1):
cmds.addAttr(self.Move_Ctrl.C, ln='MoveCtrl', at='message')
# add Attr
if not cmds.attributeQuery(
'slaveJoint', node=self.Move_Ctrl.C, exists=1):
cmds.addAttr(self.Move_Ctrl.C, ln='slaveJoint', at='message')
if not cmds.attributeQuery(
'rootJoint', node=self.Move_Ctrl.C, exists=1):
cmds.addAttr(self.Move_Ctrl.C, ln='rootJoint', at='message')
for axis in ['y', 'z']:
cmds.connectAttr(self.Master_Ctrl.C + '.sx',
self.Master_Ctrl.C + '.s' + axis)
cmds.setAttr(self.Master_Ctrl.C + '.s' + axis, k=0)
cmds.aliasAttr('Global_Scale', self.Master_Ctrl.C + '.sx')
# create a grp for objects are not influenced by rig moving
self.dontTouchGrp = cmds.group(n='Dont_Touch_Grp', em=1, p=self.topGrp)
# lock the inherits Transform attr
cmds.setAttr(self.dontTouchGrp + '.it', 0, l=1)
cmds.select(cl=1)
# create setting group for further operation
self.settingGrp = cmds.group(n=characterName + '_SettingGrp',
em=1,
p=self.dontTouchGrp)
# add attrs to setting group
Base.addAttr(group=self.settingGrp)
# connect attr
cmds.connectAttr(self.settingGrp + '.MasterCtrl',
self.Master_Ctrl.C + '.MasterCtrl',
f=1)
cmds.connectAttr(self.settingGrp + '.MoveCtrl',
self.Move_Ctrl.C + '.MoveCtrl',
f=1)
#--------------------------
#Start
pygame.init()
#Pygame Initialization
mode_flags = 0
if cfg.fullscreen:
mode_flags |= pygame.FULLSCREEN
screen = pygame.display.set_mode((cfg.width, cfg.height), mode_flags)
#Constants and Resource Objects
clock = pygame.time.Clock()
topleft = (0,0)
resources = loader.Load()
controls = control.Control()
scanlines = scanline.Scanline( cfg.scanlineSkip,
cfg.scanlineSpeed,
cfg.width,
cfg.height,
cfg.scanlineColor)
menu = menu.Menu(resources)
game = game.Game(resources,menu)
running = 1
framerate = cfg.DEFAULT_FRAMERATE
background= resources.getBackground()
#Set Captions and Icons
pygame.display.set_icon(resources.getTriangle())
pygame.display.set_caption("Spacefuck")
comms.Socket_Comms('socket.sock') as comms:
camera.resolution = (80, 60) # (320, 240)
read_fifo = "read.fifo"
write_fifo = "write.fifo"
motion = motor.Motion(comms)
control_params = control.Control_Parameters(forward_steps=4,
forward_speed=160,
reversing_steps=10,
reversing_speed=200,
turning_steps=10,
turning_speed=320,
finding_bend_steps=100,
finding_bend_speed=320)
control = control.Control(motion, control_params)
analyser = line_analysis.Line_Analyser()
time.sleep(2)
#Use the video-port for captures...
timeit = util.Time_It('Overall')
with picamera.array.PiRGBArray(camera) as stream:
for foo in camera.capture_continuous(stream,
'bgr',
use_video_port=True):
timeit.finish()
timeit = util.Time_It('Overall')
image = stream.array
lines = analyser.get_lines(image, 10)
control.progress(lines)
#print(stream.read())
stream.seek(0)
def main():
new_game = game.Game()
new_control = control.Control(new_game)
