Beispiel #1
0
def run():
    dummy_env = get_env(env_name)
    model = ActorCritic(dummy_env.observation_space.shape[0] * num_stack,
                        dummy_env.action_space)
    del dummy_env
    optimizer = optimizer = optim.RMSprop(
        model.parameters(), lr, eps=eps, alpha=alpha)
    train(model, optimizer, lambda: get_env(env_name), num_envs, num_stack,
          num_steps, num_updates, gamma, value_loss_coef, entropy_coef,
          max_grad_norm)
Beispiel #2
0
def test_get_env():
    ret = env.get_env(TEST_BASH_FILE)
    assert ret['FIRST'] == '1'
    assert ret['FILE'] == 'the file'
    assert os.environ['FIRST'] == '1'
    assert os.environ['FILE'] == 'the file'

    ret2 = env.get_env(profile_dir=dirname(TEST_BASH_FILE), prefix='ctools')
    print(ret2)
    assert ret2['CTOOLS'] == 'YES'
Beispiel #3
0
    def __init__(self, X, Y, Z, pos=None, rpy=None, color='r', name=None,
                 pose=None, visible=True, transparency=None):
        """
        Create a new rectangular box.

        X -- box half-length
        Y -- box half-width
        Z -- box half-height
        pos -- initial position in inertial frame
        rpy -- initial orientation in inertial frame
        color -- color letter in ['r', 'g', 'b']
        name -- object's name (optional)
        pose -- initial pose (supersedes pos and rpy)
        visible -- initial box visibility
        transparency -- transparency value, 0. is opaque and 1. is transparent
        """
        if not name:
            name = "Box-%s" % str(uuid.uuid1())[0:3]
        self.X = X
        self.Y = Y
        self.Z = Z
        aabb = [0, 0, 0, X, Y, Z]
        env = get_env()
        with env:
            box = openravepy.RaveCreateKinBody(env, '')
            box.InitFromBoxes(array([array(aabb)]), True)
            super(Box, self).__init__(
                box, pos=pos, rpy=rpy, color=color, name=name, pose=pose,
                visible=visible, transparency=transparency)
            env.Add(box, True)
Beispiel #4
0
    def _setup(self):
        self.env_id = "CartPole-v0"
        self.env, self.val_env = get_env(self.env_id)

        self.config = {
            "num_trials": 5,
            "num_frames": 30000,
            "num_val_trials": 10,
            "batch_size": 32,
            "gamma": 0.99,
            "method": 'our',
            "var": 1.,
            "mean": 0.,
            "decision_eps": 1.,
            "theta": 1.,
            "cnn": False,
            "invert_actions": False,
            "return_latent": 'second_hidden',
            "num_val_trials": 10,
            "batch_size": 32,
            "gamma": 0.99,
            "num_trials": 5,
            "USE_CUDA": True,
            "device": "",
            "eps": 1.,
            "num_workers": 0,
            "num_gpus": 0,
            # These params are tuned from a fixed starting value.
            "lr": 1e-4
            # These params start off randomly drawn from a set.
        }
Beispiel #5
0
def draw_3d_cone(apex, axis, section, combined='r-#', color=None, linewidth=2.,
                 pointsize=0.05):
    """
    Draw a 3D cone defined from its apex, axis vector and a cross-section
    polygon (defined in the plane orthogonal to the axis vector).

    INPUT:

    - ``apex`` -- position of the origin of the cone in world coordinates
    - ``axis`` -- unit vector directing the cone axis and lying inside the cone
    - ``combined`` -- (default: 'g-#') drawing spec in matplotlib fashion: color
      letter followed by faces to draw (see ``color`` and ``faces``)
    - ``linewidth`` -- thickness of the edges of the cone
    - ``pointsize`` -- point size in meters

    OUTPUT:

    A list of OpenRAVE handles. Must be stored in some variable, otherwise the
    drawn object will vanish instantly.
    """
    if len(section) < 1:
        warn("Trying to draw an empty cone")
        return []
    color = color if color is not None else _matplotlib_to_rgba(combined[0])
    env = get_env()
    handles = draw_polygon(
        points=section, normal=axis, combined=combined, color=color)
    edges = vstack([[apex, vertex] for vertex in section])
    edges = array(edges)
    edge_color = array(color) * 0.7
    edge_color[3] = 1.
    handles.append(env.drawlinelist(
        edges, linewidth=linewidth, colors=edge_color))
    return handles
Beispiel #6
0
def check_env_vars(env_vars):
  """Checks if the env variables are set as required to run the test.

  Returns:
    True if all the env variables are set as required, otherwise False.
  """

  if not env_vars:
    return True
  for key in env_vars:
    if env.get_env(key) != env_vars.get(key):
      return False
  return True
Beispiel #7
0
 def draw_force_lines(self, length=0.25):
     env = get_env()
     self.gui_handles = []
     for c in self.vertices:
         color = [0.1, 0.1, 0.1]
         color[numpy.random.randint(3)] += 0.2
         for f in self.force_span:
             self.gui_handles.append(env.drawlinelist(
                 array([c, c + length * f]),
                 linewidth=1, colors=color))
         self.gui_handles.append(env.drawlinelist(
             array([c, c + length * self.n]),
             linewidth=5, colors=color))
Beispiel #8
0
def check_env_vars(env_vars):
    """Checks if the env variables are set as required to run the test.

  Returns:
    True if all the env variables are set as required, otherwise False.
  """

    if not env_vars:
        return True
    for key in env_vars:
        if env.get_env(key) != env_vars.get(key):
            return False
    return True
Beispiel #9
0
    def get(self, url_nonce):
        util.EnableCors(self)
        user = model.User.all().filter("url_nonce =", url_nonce).get()
        if user is None:
            self.error(404)
            self.response.write("user not found")
            return

        # maybe we should do sum instead?
        biggest_pledge = None
        biggest_amount = 0
        for pledge in itertools.chain(
            model.Pledge.all().filter("email =", user.email), model.WpPledge.all().filter("email =", user.email)
        ):
            if (pledge.amountCents or 0) >= biggest_amount:
                biggest_pledge = pledge
                biggest_amount = pledge.amountCents or 0

        if biggest_pledge is None:
            self.error(404)
            self.response.write("user not found")
            return

        stripe.api_key = env.get_env().stripe_backend.stripe_private_key
        cus = stripe.Customer.retrieve(biggest_pledge.stripeCustomer)
        if len(cus.cards.data) == 0:
            self.error(404)
            self.response.write("user not found")
            return

        if user.first_name or user.last_name:
            # TODO(jt): we should backfill this information
            user_name = "%s %s" % (user.first_name or "", user.last_name or "")
        else:
            user_name = cus.cards.data[0].name

        zip_code = cus.cards.data[0].address_zip

        self.response.headers["Content-Type"] = "application/javascript"
        self.response.write(
            json.dumps(
                {
                    "user": {
                        "name": user_name,
                        "email": user.email,
                        "pledge_amount_cents": biggest_amount,
                        "zip_code": zip_code,
                    }
                }
            )
        )
Beispiel #10
0
    def get(self, url_nonce):
        util.EnableCors(self)
        user = model.User.all().filter('url_nonce =', url_nonce).get()
        if user is None:
            self.error(404)
            self.response.write('user not found')
            return

        # maybe we should do sum instead?
        biggest_pledge = None
        biggest_amount = 0
        for pledge in itertools.chain(
                model.Pledge.all().filter('email =', user.email),
                model.WpPledge.all().filter('email =', user.email)):
            if (pledge.amountCents or 0) >= biggest_amount:
                biggest_pledge = pledge
                biggest_amount = (pledge.amountCents or 0)

        if biggest_pledge is None:
            self.error(404)
            self.response.write("user not found")
            return

        cc_user_name = None
        cc_zip_code = None
        stripe.api_key = env.get_env().stripe_backend.stripe_private_key
        if biggest_pledge.stripeCustomer:
            cus = stripe.Customer.retrieve(biggest_pledge.stripeCustomer)

            if len(cus.sources.data) > 0:
                cc_user_name = cus.sources.data[0].name
                cc_zip_code = cus.sources.data[0].address_zip

        if user.first_name or user.last_name:
            # TODO(jt): we should backfill this information
            user_name = "%s %s" % (user.first_name or "", user.last_name or "")
        else:
            user_name = cc_user_name

        zip_code = cc_zip_code

        self.response.headers['Content-Type'] = 'application/javascript'
        self.response.write(
            json.dumps({
                "user": {
                    "name": user_name,
                    "email": user.email,
                    "pledge_amount_cents": biggest_amount,
                    "zip_code": zip_code
                }
            }))
Beispiel #11
0
    def __init__(self, path=None, xml=None, qd_lim=None):
        """
        Create a new robot model.

        INPUT:

        - ``path`` -- path to the COLLADA model of the robot
        - ``xml`` -- (optional) string in OpenRAVE XML format
        - ``qd_lim`` -- maximum angular joint velocity (in [rad] / [s])
        """
        assert path is not None or xml is not None
        name = basename(splitext(path)[0])
        if xml is None:
            xml = Robot.__default_xml % (path, name)
        env = get_env()
        env.LoadData(xml)
        rave = env.GetRobot(name)
        nb_dofs = rave.GetDOF()
        set_default_background_color()  # [dirty] reset by LoadData
        q_min, q_max = rave.GetDOFLimits()
        rave.SetDOFVelocities([0] * nb_dofs)
        rave.SetDOFVelocityLimits([1000.] * nb_dofs)
        if qd_lim is None:
            qd_lim = 10.  # [rad] / [s]; this is already quite fast
        qd_max = +qd_lim * ones(nb_dofs)
        qd_min = -qd_lim * ones(nb_dofs)

        self.active_dofs = None
        self.has_free_flyer = False
        self.ik = None  # created by self.init_ik()
        self.ik_lock = None
        self.ik_thread = None
        self.is_visible = True
        self.mass = sum([link.GetMass() for link in rave.GetLinks()])
        self.nb_dofs = nb_dofs
        self.q_max = q_max
        self.q_max.flags.writeable = False
        self.q_max_active = None
        self.q_min = q_min
        self.q_min.flags.writeable = False
        self.q_min_active = None
        self.qd_max = qd_max
        self.qd_max_active = None
        self.qd_min = qd_min
        self.qd_min_active = None
        self.qdd_max = None  # set in child class
        self.rave = rave
        self.tau_max = None  # set by hand in child robot class
        self.transparency = 0.  # initially opaque
Beispiel #12
0
def draw_arrow(p1, p2, color='r', linewidth=0.02):
    """
    Draw an arrow between two points.

    INPUT:

    - ``p1`` -- 3D coordinates of the origin of the arrow
    - ``p2`` -- 3D coordinates of the end of the arrow
    - ``color`` -- (default: 'r') matplotlib color letter or RGB triplet
    - ``linewidth`` -- thickness of force vector

    OUTPUT:

    And OpenRAVE handle. Must be stored in some variable, otherwise the drawn
    object will vanish instantly.
    """
    if type(color) is str:
        color = _matplotlib_to_rgb(color)
    return get_env().drawarrow(p1, p2, linewidth=linewidth, color=color)
Beispiel #13
0
def draw_line(p1, p2, color='g', linewidth=1.):
    """
    Draw a line between points p1 and p2.

    INPUT:

    - ``p1`` -- one end of the line
    - ``p2`` -- other end of the line
    - ``color`` -- (default: 'g') matplotlib color letter or RGB triplet
    - ``linewidth`` -- thickness of drawn line

    OUTPUT:

    And OpenRAVE handle. Must be stored in some variable, otherwise the drawn
    object will vanish instantly.
    """
    if type(color) is str:
        color = _matplotlib_to_rgb(color)
    return get_env().drawlinelist(
        array([p1, p2]), linewidth=linewidth, colors=color)
Beispiel #14
0
def init_components(args, unknown_args) -> Tuple[Env, Agent]:
    # Initialize environment
    env = get_env(args.env, **unknown_args)

    # Get model class
    if args.model is not None:
        model_cls = model_registry.get(args.model)
    else:
        env_type = _get_gym_env_type(args.env)
        if env_type == 'atari':
            model_cls = model_registry.get('qcnn')
        elif env_type == 'classic_control':
            model_cls = model_registry.get('qmlp')
        else:
            raise NotImplementedError(
                f'No default model for environment: {args.env!r})')

    # Initialize agent
    agent_cls = agent_registry.get(args.alg)
    agent = agent_cls(model_cls, env.get_observation_space(),
                      env.get_action_space(), args.agent_config,
                      **unknown_args)

    return env, agent
Beispiel #15
0
def draw_force(p, f, scale=0.005, color='r', linewidth=0.015):
    """
    Draw a force acting at a given point.

    INPUT:

    - ``p`` -- point where the force is acting
    - ``f`` -- force vector
    - ``color`` -- (default: 'r') matplotlib color letter or RGB triplet
    - ``scale`` -- scaling factor between Euclidean and Force spaces
    - ``linewidth`` -- thickness of force vector

    OUTPUT:

    And OpenRAVE handle. Must be stored in some variable, otherwise the drawn
    object will vanish instantly.
    """
    if type(color) is str:
        color = _matplotlib_to_rgb(color)
    f_scale = scale * f
    if dot(f_scale, f_scale) < 1e-6:
        return None
    return get_env().drawarrow(
        p, p + f_scale, linewidth=linewidth, color=color)
Beispiel #16
0
            self.response.write('Command started.')

        def _get_cmd(self):
            if 'cmds' not in self.app.registry:
                self.app.registry['cmds'] = {}
            if cmd_cls.SHORT_NAME not in self.app.registry['cmds']:
                self.app.registry['cmds'][cmd_cls.SHORT_NAME] = cmd_cls(
                    self.app.config)
            return self.app.registry['cmds'][cmd_cls.SHORT_NAME]

    return ('/admin/command/' + cmd_cls.SHORT_NAME, H)


COMMAND_HANDLERS = [MakeCommandHandler(c) for c in commands.COMMANDS]

app = webapp2.WSGIApplication([
    ('/admin/generate/pledge_amounts.csv', GeneratePledgeAmountsCsvHandler),
    ('/admin/generate/pledges.csv', GeneratePledgesCsvHandler),
    ('/admin/generate/pledges_full_data.csv',
     GeneratePledgesFullDataCsvHandler),
    ('/admin/files(.+)/pledge_amounts.csv', CsvHandler),
    ('/admin/files(.+)/pledges.csv', CsvHandler),
    ('/admin/files(.+)/pledges_full_data.csv', CsvHandler),
    ('/admin/pledges_export', PledgesExportHandler),
    ('/admin/pledges_export/pledges.json', PledgesExportJSONHandler),
    ('/admin/stretch', StretchHandler),
    ('/admin/?', AdminDashboardHandler),
] + COMMAND_HANDLERS,
                              debug=False,
                              config=dict(env=env.get_env()))
logging.config.fileConfig('logging.ini')

from apscheduler.triggers.cron import CronTrigger
from apscheduler.schedulers.background import BackgroundScheduler, BlockingScheduler

from env import get_env
from server import AuthServer
from dump import dump_database
from slack import send_slack_message

logger = logging.getLogger('ddgscheduler')


if __name__ == "__main__":
    environment = get_env()

    if environment.get('TEST'):
        import time
        time.sleep(10)
        dump_database(environment)
        time.sleep(300)
    else:
        if environment.get('START_MANUAL_MANAGEMENT_SERVER'):
            dumper_scheduler = BackgroundScheduler()
        else:
            dumper_scheduler = BlockingScheduler()

        dumper_scheduler.add_job(lambda: dump_database(environment), CronTrigger.from_crontab(environment.get('CRON')))
        dumper_scheduler.start()
Beispiel #18
0
     to be executed.
  """
  class H(webapp2.RequestHandler):
    def get(self):
      self.response.write("""
      <h1>You are about to run command "{}". Are you sure?</h1>
      <form action="" method="POST">
      <button>Punch it</button>
      </form>""".format(self._get_cmd().NAME))

    def post(self):
      deferred.defer(self._get_cmd().run)
      self.response.write('Command started.')

    def _get_cmd(self):
      if 'cmds' not in self.app.registry:
        self.app.registry['cmds'] = {}
      if cmd_cls.SHORT_NAME not in self.app.registry['cmds']:
        self.app.registry['cmds'][cmd_cls.SHORT_NAME] = cmd_cls(self.app.config)
      return self.app.registry['cmds'][cmd_cls.SHORT_NAME]

  return ('/admin/command/' + cmd_cls.SHORT_NAME, H)


COMMAND_HANDLERS = [MakeCommandHandler(c) for c in commands.COMMANDS]

app = webapp2.WSGIApplication([
  ('/admin/pledges.csv', PledgesCsvHandler),
  ('/admin/?', AdminDashboardHandler),
] + COMMAND_HANDLERS, debug=False, config=dict(env=env.get_env()))
Beispiel #19
0
def main():
    main_arg_parser = argparse.ArgumentParser(description="The PrAE Learner")
    subparsers = main_arg_parser.add_subparsers(title="subcommands",
                                                dest="subcommand")

    train_arg_parser = subparsers.add_parser("train",
                                             help="parser for training")
    train_arg_parser.add_argument("--epochs",
                                  type=int,
                                  default=200,
                                  help="the number of training epochs")
    train_arg_parser.add_argument("--batch-size",
                                  type=int,
                                  default=32,
                                  help="size of batch")
    train_arg_parser.add_argument("--seed",
                                  type=int,
                                  default=1234,
                                  help="random number seed")
    train_arg_parser.add_argument(
        "--device",
        type=int,
        default=0,
        help="device index for GPU; if GPU unavailable, leave it as default")
    train_arg_parser.add_argument(
        "--dataset",
        type=str,
        default="/home/chizhang/Datasets/RAVEN-10000/",
        help="dataset path")
    train_arg_parser.add_argument("--config",
                                  type=str,
                                  default="distribute_four",
                                  help="the configuration used for training")
    train_arg_parser.add_argument("--checkpoint-dir",
                                  type=str,
                                  default="./runs/ckpt/",
                                  help="checkpoint save path")
    train_arg_parser.add_argument("--save-dir",
                                  type=str,
                                  default="./runs/save/",
                                  help="final model save path")
    train_arg_parser.add_argument("--log-dir",
                                  type=str,
                                  default="./runs/log/",
                                  help="log save path")
    train_arg_parser.add_argument("--img-size",
                                  type=int,
                                  default=32,
                                  help="image region size for training")
    train_arg_parser.add_argument("--lr",
                                  type=float,
                                  default=0.95e-4,
                                  help="learning rate")
    train_arg_parser.add_argument(
        "--weight-decay",
        type=float,
        default=0.0,
        help="weight decay of optimizer, same as l2 reg")
    train_arg_parser.add_argument(
        "--error",
        type=str,
        default="JSD",
        help="error used to measure difference between distributions")
    train_arg_parser.add_argument("--num-workers",
                                  type=int,
                                  default=2,
                                  help="number of workers for data loader")
    train_arg_parser.add_argument("--resume",
                                  type=str,
                                  default=None,
                                  help="resume from a initialized model")
    train_arg_parser.add_argument("--aux",
                                  type=float,
                                  default=1.0,
                                  help="weight of auxiliary training")

    test_arg_parser = subparsers.add_parser("test", help="parser for testing")
    test_arg_parser.add_argument("--batch-size",
                                 type=int,
                                 default=32,
                                 help="size of batch")
    test_arg_parser.add_argument(
        "--device",
        type=int,
        default=0,
        help="device index for GPU; if GPU unavailable, leave it as default")
    test_arg_parser.add_argument("--dataset",
                                 type=str,
                                 default="/home/chizhang/Datasets/RAVEN-10000",
                                 help="dataset path")
    test_arg_parser.add_argument("--config",
                                 type=str,
                                 default="distribute_four",
                                 help="the configuration used for testing")
    test_arg_parser.add_argument("--model-path",
                                 type=str,
                                 required=True,
                                 help="path to a trained model")
    test_arg_parser.add_argument("--img-size",
                                 type=int,
                                 default=32,
                                 help="image region size for training")
    test_arg_parser.add_argument(
        "--error",
        type=str,
        default="JSD",
        help="error used to measure difference betweeen distributions")
    test_arg_parser.add_argument("--shuffle",
                                 type=int,
                                 default=0,
                                 help="whether to shuffle the dataset")
    test_arg_parser.add_argument("--num-workers",
                                 type=int,
                                 default=2,
                                 help="number of workers for data loader")

    args = main_arg_parser.parse_args()
    args.cuda = torch.cuda.is_available()
    device = torch.device("cpu")
    # device = torch.device("cuda:{}".format(args.device) if args.cuda else "cpu")

    env = get_env(args.config, device)
    if env is None:
        print("ERROR: Unsupported environment")
        sys.exit(1)

    if args.subcommand is None:
        print("ERROR: Specify train or test")
        sys.exit(1)

    if args.subcommand == "train":
        check_paths(args)
        train(args, env, device)
    elif args.subcommand == "test":
        test(args, env, device)
    else:
        print("ERROR: Unknown subcommand")
        sys.exit(1)
Beispiel #20
0
if __name__ == "__main__":
    import sys

    from presets import preset
    preset.load_default()

    exp_settings = preset.experiment
    env_settings = preset.env
    env_settings.enable_rendering = True

    for i in range(1, len(sys.argv) - 1):
        preset.load_custom(sys.argv[i])

    preset.load_env_override()

    checkpoint = sys.argv[-1]

    from env import get_env
    test_env = get_env(exp_settings.env)(seed=0, evaluate=True)

    from algorithm import algorithm_bundle_dict
    algorithm_name = preset.experiment.algorithm
    model_class = algorithm_bundle_dict[algorithm_name].model_class

    from model import model_dict
    load_model = model_dict[model_class].loader

    model = load_model(checkpoint)
    test_model(test_env, model, exp_settings.record_motion)
Beispiel #21
0
def draw_points(points, color='g', pointsize=0.05):
    if type(color) is str:
        color = _matplotlib_to_rgba(color, alpha=1.)
    return get_env().plot3(
        array(points), pointsize=pointsize, drawstyle=1,
        colors=color)
Beispiel #22
0
    import sys

    from presets import preset
    preset.load_default()

    exp_settings = preset.experiment
    env_settings = preset.env
    env_settings.enable_rendering = True

    for i in range(1, len(sys.argv) - 1):
        preset.load_custom(sys.argv[i])

    preset.load_env_override()

    checkpoint = sys.argv[-1]

    from env import get_env
    test_env = get_env(exp_settings.env)(seed=0,
                                         checkpoint=checkpoint,
                                         evaluate=True)

    from algorithm import algorithm_bundle_dict
    algorithm_name = preset.experiment.algorithm
    model_class = algorithm_bundle_dict[algorithm_name].model_class

    from model import model_dict
    load_model = model_dict[model_class].loader

    model = load_model(checkpoint)
    test_model(test_env, model, exp_settings.record_motion)
Beispiel #23
0
 def remove(self):
     """Remove body from OpenRAVE environment."""
     env = get_env()
     with env:
         env.Remove(self.rave)
Beispiel #24
0
def rl2d(config: dict, run_args: dict) -> VAEExperiment:
    run_config = config['run_params']['config']
    env = get_env(run_config['env_config']['name'])
    run_config = {**run_config, 'framework': 'torch', 'env': env}
    config['run_params']['config'] = run_config
    tune.run(config['algorithm'], loggers=[TBXLogger], **config['run_params'])
Beispiel #25
0
            json.dumps(
                {
                    "user": {
                        "name": user_name,
                        "email": user.email,
                        "pledge_amount_cents": biggest_amount,
                        "zip_code": zip_code,
                    }
                }
            )
        )

    def options(self):
        util.EnableCors(self)


app = webapp2.WSGIApplication(
    [
        ("/total", GetTotalHandler),
        (r"/user-update/(\w+)", UserUpdateHandler),
        (r"/user-info/(\w+)", UserInfoHandler),
        ("/campaigns/may-one/?", EmbedHandler),
        ("/contact.do", ContactHandler),
        # See wp_import
        # ('/import.do', wp_import.ImportHandler),
    ]
    + handlers.HANDLERS,
    debug=False,
    config=dict(env=env.get_env()),
)
Beispiel #26
0
import time
import board
import neopixel
import math
import env

e = env.get_env()
COUNTDOWN_DELAY = e['COUNTDOWNDELAY']

# Choose an open pin connected to the Data In of the NeoPixel strip, i.e. board.D18
# NeoPixels must be connected to D10, D12, D18 or D21 to work.
pixel_pin = board.D18

# The number of NeoPixels
num_pixels = 20

# The order of the pixel colors - RGB or GRB. Some NeoPixels have red and green reversed!
# For RGBW NeoPixels, simply change the ORDER to RGBW or GRBW.
ORDER = neopixel.GRB
DEFAULT_BRIGHTNESS = 0.2

pixels = neopixel.NeoPixel(pixel_pin,
                           num_pixels,
                           brightness=DEFAULT_BRIGHTNESS,
                           auto_write=False,
                           pixel_order=ORDER)

rainbow_count = 0


def wheel(pos):
Beispiel #27
0
def draw_polyhedron(points, combined='g-#', color=None, faces=None,
                    linewidth=1., pointsize=0.01, hull=None):
    """
    Draw a polyhedron defined as the convex hull of a set of points.

    INPUT:

    - ``points`` -- list of 3D points
    - ``combined`` -- (default: 'g-#') drawing spec in matplotlib fashion: color
      letter followed by faces to draw (see ``color`` and ``faces``)
    - ``color`` -- color letter or RGBA tuple
    - ``faces`` -- string of symbols indicating the faces of the polyhedron to
      draw: use '.' for vertices, '-' for edges and '#' for facets
    - ``hull`` -- used in the 2D case where the hull has zero volume
    - ``linewidth`` -- line thickness in meters
    - ``pointsize`` -- point size in meters

    OUTPUT:

    And OpenRAVE handle. Must be stored in some variable, otherwise the drawn
    object will vanish instantly.
    """
    is_2d = hull is not None
    if color is None:
        color = combined[0]
    if faces is None:
        faces = combined[1:]
    if type(color) is str:
        color = _matplotlib_to_rgba(color)
    if hull is None:
        try:
            hull = ConvexHull(points)
        except QhullError:
            warn("QhullError: maybe polyhedron is empty?")
            return []
    vertices = array([points[i] for i in hull.vertices])
    points = array(points)
    color = array(color if color is not None else (0.0, 0.5, 0.0, 0.5))
    handles = []
    env = get_env()
    if '-' in faces:  # edges
        edge_color = color * 0.7
        edge_color[3] = 1.
        edges = vstack([[points[i], points[j]]
                        for s in hull.simplices
                        for (i, j) in itertools.combinations(s, 2)])
        edges = array(edges)
        handles.append(env.drawlinelist(
            edges, linewidth=linewidth, colors=edge_color))
    if '#' in faces:  # facets
        if is_2d:
            nv = len(vertices)
            indices = array([(0, i, i + 1) for i in xrange(nv - 1)], int64)
            handles.append(env.drawtrimesh(vertices, indices, colors=color))
        else:
            indices = array(hull.simplices, int64)
            handles.append(env.drawtrimesh(points, indices, colors=color))
    if '.' in faces:  # vertices
        color[:3] *= 0.75
        color[3] = 1.
        handles.append(env.plot3(
            vertices, pointsize=pointsize, drawstyle=1, colors=color))
    return handles