text:
layout: default
---

Context and Background

        3D User Interfaces (3DUIs) support many important applications, including: creating virtual scenes
        for video games and movies; creating models for 3D printing and viewing 3D models of medical information.
        Despite the importance of these applications, the 3D user interfaces of these modelling packages
        have not changed much since their inception. While many interfaces have been proposed, most 3DUIs have not changed.
        In order to determine the strengths of different interfaces, we performed two experiments:

             Interactive Shadows against a traditional 3DUI with three orthographic views with three different tasks.

             The three most prevalent controllers (Arcball, Two Axis Valuator, and Discrete Sliders) with the two types of tasks of differing difficulty.

 Rotation controller is used to rotate a liver with tumor. Source: Bade, Ragnar, Felix Ritter, and Bernhard Preim. "Usability comparison of mouse-based interaction techniques for predictable 3d rotation." Smart graphics. Springer Berlin Heidelberg, 2005.

Below we present a summary of our goals and findings. Please see documents for our full proposal and reports.

Project Goals

We aim to determine whether:

Interactive Shadows performs better than traditional multi-view 3DUIs

One of the methods of rotation tested is better suited to certain class of tasks than the others

        Left: Traditional multi-view 3DUI designed to compare against Interactive Shadows.

 Right: Appearance of the Interactive Shadows controller.

        Appearance and interaction design for the rotation controllers. From top to bottom: Discrete Sliders, Arcball and Two Axis Valuator.

Results

Interactive Shadows Evaluation Findings

  Interactive shadows were found to be significantly better in terms of distance accuracy for one task, which relied on participant distance estimations. This suggests that the interactive shadows interface might help users approximate relative object positioning.  No other significant interactions were found. We found key confounding factors that could contribute to participant performance and also draw attention to concepts that could help future researchers in this area when
  conducting similar investigations.

        Results for Interactive Shadows Evaluation

Rotation Controller Evaluation Findings

We found no statistically significant differences between Arcball and Two Axis Valuator. However, we found the Discrete Sliders to be significantly more accurate for simple matching tasks (a medium to large effect) but slower for complex matching, and inspection tasks (a small to medium effect of approximately two seconds). This indicates that the Discrete Sliders are most appropriate in situations where fine-grained accuracy is valued over speed, while for other tasks, such as
inspection, either Arcball or Two Axis Valuator are better suited.

    Results for Rotation Controller Evaluation

Resources

Documents

Project Proposal

Review of 3D Scene Manipulations

Review of 3D Rotation Controllers

Proposal and plan for the website

Timeline

Poster

Report on Interactive Shadows Evaluation

Report on 3D Rotation Controller Evaluation

Minutes

    {% for post in site.posts %}

          {{ post.date | date: "%b %-d, %Y" }}

    {% endfor %}


text:
/**
   This program tests the Student class.
*/
public class CSMajorStudentTester
{
   public static void main(String[] args)
   {
      CSMajorStudent oneNewCSStudent = new CSMajorStudent(000542274, "Smith", "Bob", 2002, 3.56, "Theory", "Computer Technology","Windows and Macintosh");

      System.out.println("The new CS student has the followings: ");
      System.out.println(oneNewCSStudent.getFirstName());
      System.out.println(oneNewCSStudent.getLastName());
      System.out.println(oneNewCSStudent.getId());
      System.out.println(oneNewCSStudent.getAge());
      System.out.println(oneNewCSStudent.getOption());
      System.out.println(oneNewCSStudent.getHours());

   }
}

redpajama_set_name: RedPajamaGithub


text:
__versioninfo__ = (0, 0, 1)
__version__ = '.'.join(str(v) for v in __versioninfo__) + "-dev"

class Version(object):
    @staticmethod
    def serialbox_version():
        from serialbox import __version__ as serialbox_vers
        return serialbox_vers

    @staticmethod
    def numpy_version():
        from numpy import __version__ as numpy_vers
        return numpy_vers

    @staticmethod
    def sdb_version():
        return __version__

    @staticmethod
    def ipython_version():
        try:
            from IPython import __version__ as ipython_vers
            return ipython_vers
        except ImportError:
            return None

    @staticmethod
    def matplotlib_version():
        try:
            from matplotlib import __version__ as matplotlib_vers
            return matplotlib_vers
        except ImportError:
            return None


text:
import React from 'react';
import midiActions from '../../helpers/midiActions';
import { otherListenerTypes } from '../../constants';
import * as noteFilters from './noteFilters';

export class FilterManager extends React.Component {
  componentWillMount() {
    this.props.dispatch({ selectedFilters: [], filteredNotes: {} });
    this.props.registeredListeners.push(this.connectListener.bind(this));
    [this.props.dawListener, this.props.midiDevice].forEach(this.connectListener.bind(this));
  }

  connectListener(device) {
    ['noteon', 'noteoff'].forEach(listenerType => {
        device.addListener(listenerType, 1, e => {
          const filteredEvents = this.props.selectedFilters.reduce((accum, filter) => filter(accum, {
            mode: this.props.mode,
            currentKey: this.props.currentKey
          }), {
            [e.note.number]: e
          });

          if (listenerType === 'noteon') {
            this.props.setFilteredNotes({ ...this.props.filteredNotes, ...filteredEvents})
          } else {
            Object.keys(filteredEvents).forEach(noteNumber =>
              this.props.deleteNote(noteNumber))
          }
          midiActions[listenerType](filteredEvents, this.props.outputDevice);
        })
      });
    otherListenerTypes.forEach(listenerType =>
        device.addListener(listenerType, 1, e => midiActions[listenerType](e, this.props.outputDevice))
      )
  }

  render() {
    const filters = this.props.selectedFilters || [];
    return (
        <div>
        { Object.keys(noteFilters).map((filter, idx) =>
            <div
              key={idx}
              onClick={() => {
                const filterFn = noteFilters[filter];
                const newFilters = (filters).includes(filterFn) ?
                  filters.filter(item => filterFn !== item) :
                  [...filters, filterFn]
                this.props.dispatch({selectedFilters: newFilters})
              }}
              style={{cursor: 'pointer', color: filters.includes(noteFilters[filter]) ? 'blue' : 'black'}}
            >
              {filter}
            </div>)}
        </div>
    )
  }
}

export default FilterManager


text:
import { Component } from "@angular/core";

import { ElectronService } from "../services/electron.service";

@Component({
    selector: "my-login",
    templateUrl: "src/login/view-login.html",
})
export class LoginComponent {
    constructor(private electronService: ElectronService) {
    }

    public login() {
        // Clear local cache
        window.localStorage.removeItem("id_token");
        window.localStorage.removeItem("access_token");
        window.localStorage.removeItem("user");

        this.electronService.logIn();
    }
}


text:
require 'uri'

module Gitlab
  module Kubernetes
    # Wrapper around Kubeclient::Client to dispatch
    # the right message to the client that can respond to the message.
    # We must have a kubeclient for each ApiGroup as there is no
    # other way to use the Kubeclient gem.
    #
    # See https://github.com/abonas/kubeclient/issues/348.
    class KubeClient
      include Gitlab::Utils::StrongMemoize

      SUPPORTED_API_GROUPS = [
        'api',
        'apis/rbac.authorization.k8s.io',
        'apis/extensions'
      ].freeze

      # Core API methods delegates to the core api group client
      delegate :get_pods,
        :get_secrets,
        :get_config_map,
        :get_namespace,
        :get_pod,
        :get_service,
        :get_service_account,
        :delete_pod,
        :create_config_map,
        :create_namespace,
        :create_pod,
        :create_service_account,
        :update_config_map,
        :update_service_account,
        to: :core_client

      # RBAC methods delegates to the apis/rbac.authorization.k8s.io api
      # group client
      delegate :create_cluster_role_binding,
        :get_cluster_role_binding,
        :update_cluster_role_binding,
        to: :rbac_client

      # Deployments resource is currently on the apis/extensions api group
      delegate :get_deployments,
        to: :extensions_client

      # non-entity methods that can only work with the core client
      # as it uses the pods/log resource
      delegate :get_pod_log,
        :watch_pod_log,
        to: :core_client

      def initialize(api_prefix, api_groups = ['api'], api_version = 'v1', **kubeclient_options)
        raise ArgumentError unless check_api_groups_supported?(api_groups)

        @api_prefix = api_prefix
        @api_groups = api_groups
        @api_version = api_version
        @kubeclient_options = kubeclient_options
      end

      def discover!
        clients.each(&:discover)
      end

      def clients
        hashed_clients.values
      end

      def core_client
        hashed_clients['api']
      end

      def rbac_client
        hashed_clients['apis/rbac.authorization.k8s.io']
      end

      def extensions_client
        hashed_clients['apis/extensions']
      end

      def hashed_clients
        strong_memoize(:hashed_clients) do
          @api_groups.map do |api_group|
            api_url = join_api_url(@api_prefix, api_group)
            [api_group, ::Kubeclient::Client.new(api_url, @api_version, **@kubeclient_options)]
          end.to_h
        end
      end

      private

      def check_api_groups_supported?(api_groups)
        api_groups.all? {|api_group| SUPPORTED_API_GROUPS.include?(api_group) }
      end

      def join_api_url(api_prefix, api_path)
        url = URI.parse(api_prefix)
        prefix = url.path.sub(%r{/+\z}, '')

        url.path = [prefix, api_path].join("/")

        url.to_s
      end
    end
  end
end


text:
package srnd

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"log"
	"net"
	"os/user"
	"strings"
)

var ErrSpamFilterNotEnabled = errors.New("spam filter access attempted when disabled")
var ErrSpamFilterFailed = errors.New("spam filter failed")
var ErrMessageIsSpam = errors.New("message is spam")

type SpamFilter struct {
	addr    string
	enabled bool
}

func (sp *SpamFilter) Configure(c SpamConfig) {
	sp.enabled = c.enabled
	sp.addr = c.addr
}

func (sp *SpamFilter) Enabled(newsgroup string) bool {
	return sp.enabled && newsgroup != "ctl"
}

type SpamResult struct {
	Err    error
	IsSpam bool
}

// feed spam subsystem a spam post
func (sp *SpamFilter) MarkSpam(msg io.Reader) (err error) {
	var buf [65636]byte

	var u *user.User
	u, err = user.Current()
	if err != nil {
		return
	}
	var conn *net.TCPConn
	conn, err = sp.openConn()
	if err != nil {
		return
	}
	defer conn.Close()
	fmt.Fprintf(conn, "TELL SPAMC/1.5\r\nUser: %s\r\nMessage-class: spam\r\nSet: local\r\n\r\n", u.Username)
	io.CopyBuffer(conn, msg, buf[:])
	conn.CloseWrite()
	r := bufio.NewReader(conn)
	io.Copy(Discard, r)
	return
}

func (sp *SpamFilter) openConn() (*net.TCPConn, error) {
	addr, err := net.ResolveTCPAddr("tcp", sp.addr)
	if err != nil {
		return nil, err
	}
	return net.DialTCP("tcp", nil, addr)
}

func (sp *SpamFilter) Rewrite(msg io.Reader, out io.WriteCloser, group string) (result SpamResult) {
	var buff [65636]byte
	if !sp.Enabled(group) {
		result.Err = ErrSpamFilterNotEnabled
		return
	}
	var u *user.User
	var c *net.TCPConn
	c, result.Err = sp.openConn()
	if result.Err != nil {
		return
	}
	u, result.Err = user.Current()
	if result.Err != nil {
		return
	}
	fmt.Fprintf(c, "PROCESS SPAMC/1.5\r\nUser: %s\r\n\r\n", u.Username)
	io.CopyBuffer(c, msg, buff[:])
	c.CloseWrite()
	r := bufio.NewReader(c)
	for {
		var l string
		l, result.Err = r.ReadString(10)
		if result.Err != nil {
			return
		}
		l = strings.TrimSpace(l)
		if strings.HasPrefix(l, "Spam: True ") {
			result.IsSpam = true
		}
		log.Println("SpamFilter:", l)
		if l == "" {
			_, result.Err = io.CopyBuffer(out, r, buff[:])
			c.Close()
			out.Close()
			return
		}
	}
	result.Err = ErrSpamFilterFailed
	return
}


text:
		<div class="col-xs-6 byline-item" title="<?php echo get_userdata($post['post_author'])->display_name; ?>">

			<a href="<?php echo get_author_posts_url($post['post_author']); ?>" rel="author" class="fn">
				<?php echo get_userdata($post['post_author'])->display_name; ?>

			<time class="published" datetime="<?php echo get_post_time('c', false, $post["ID"]); ?>">
				<?php echo get_post_time('j/n/Y', false, $post["ID"]); ?>
			</time>