예제 #1
0
def draw_rectangle(width, height, color, line_width=2):
    glColor3f(*color)
    glLineWidth(line_width)
    glBegin(GL_LINE_LOOP)
    for coords in [[1, 1], [1, -1], [-1, -1], [-1, 1]]:
        glVertex2f(*shift_scale_point(
            vec.Vec([width / 2, height / 2]) * vec.Vec(coords)))
    glEnd()
예제 #2
0
def rvec():
    import vec
    D = {'radio', 'sensor', 'memory', 'cpu'}
    v0 = vec.Vec(D, {'radio': 1, 'cpu': 3})
    v1 = vec.Vec(D, {'sensor': 2, 'cpu': 4})
    v2 = vec.Vec(D, {'memory': 3, 'cpu': 1})
    VT = [v0, v1, v2]
    return VT
예제 #3
0
    def as_vec(self):
        """
        This function returns the value of the vector as a Vec class

        :return: Vec instance
        """
        return vec.Vec(self.as_list())
예제 #4
0
def init(size, draw_origin=vec.Vec([0.0, 0.0, -15.0]), focal=4, stereo=True):
    this.size = size
    this.size = size
    this.width, this.height = size
    this.screen = pygame.display.set_mode(
        this.size, pygame.HWSURFACE | pygame.OPENGL | pygame.DOUBLEBUF)
    initGL()
    resize(*size)
def signum(u):
    """
  input: a Vec u
  output: the Vec v with the same domain as u such that
          +1 if u[d] >= 0
  v[d]= {
          -1 if u[d] < 0
  """
    return vec.Vec(u.D, {d: 1 if u[d] >= 0 else -1 for d in u.D})
예제 #6
0
def draw_points_2d(points, color, line_width=2):
    glColor3f(*color)
    #draw each point as a line with (almost) identical start and end points
    glLineWidth(line_width)
    for point in points:
        glBegin(GL_LINES)
        glVertex2f(*shift_scale_point(point))
        glVertex2f(*(shift_scale_point(point) + vec.Vec([1, 0])))
        glEnd()
예제 #7
0
def image2vector(image):
    D = set()
    F = {}
    for i in range(len(image)):
        row = image[i]
        for j in range(len(row)):
            pixel = row[j]
            coord = (i, j)
            D.add(coord)
            F[coord] = pixel
    return vec.Vec(D, F)
예제 #8
0
def draw_circle_2d(radius,
                   color,
                   n_points=60,
                   line_width=2,
                   draw_origin=vec.zero_vec(2)):
    glColor3f(*color)
    glLineWidth(line_width)
    glBegin(GL_LINE_LOOP)
    for i in range(n_points):
        x = math.cos(math.pi * 2 * i / n_points) * radius
        y = math.sin(math.pi * 2 * i / n_points) * radius
        p = vec.Vec([x, y]) + draw_origin
        glVertex2f(*shift_scale_point(p))
    glEnd()
예제 #9
0
def draw_points_3d(points, color, draw_origin, draw_angles, line_width=2):
    gl.glLoadIdentity()  # reset position
    gl.glTranslatef(*draw_origin)
    #origin of plotting
    gl.glRotatef(draw_angles[1], 1, 0, 0)
    gl.glRotatef(draw_angles[0], 0, 1, 0)

    glColor3f(*color)
    #draw each point as a line with (almost) identical start and end points
    glLineWidth(line_width)
    for point in points:
        glBegin(GL_LINES)
        glVertex3f(*point)
        glVertex3f(*(point + vec.Vec([0.01, 0, 0])))
        glEnd()
예제 #10
0
파일: image.py 프로젝트: pcp135/C-CtM
def image2vec(image):
    """ Converts an image in list of lists format to a vector. Will work with
        either color or grayscale. """
    if isgray(image):
        D = {(x, y) for x in range(len(image[0])) for y in range(len(image))}
        F = {(x, y): image[y][x] for (x, y) in D}
    else:
        D = {(x, y, c)
             for c in ['r', 'g', 'b'] for x in range(len(image[0]))
             for y in range(len(image))}
        F = dict()
        for y in range(len(image)):
            for x in range(len(image[y])):
                F[(x, y, 'r')] = image[y][x][0]
                F[(x, y, 'g')] = image[y][x][1]
                F[(x, y, 'b')] = image[y][x][2]
    return vec.Vec(D, F)
예제 #11
0
    return cancer_data.read_training_data('inner_product/train.data')


def signum(u):
    """
  input: a Vec u
  output: the Vec v with the same domain as u such that
          +1 if u[d] >= 0
  v[d]= {
          -1 if u[d] < 0
  """
    return vec.Vec(u.D, {d: 1 if u[d] >= 0 else -1 for d in u.D})


assert (signum(vec.Vec({'A', 'B'}, {
    'A': 3,
    'B': -2
})) == vec.Vec({'A', 'B'}, {
    'A': 1,
    'B': -1
}))


def fraction_wrong(A, b, w):
    """
  input: An R x C matrix A whose rows are feature vectors,
  an R-vector b whose entries are +1 and -1,
  and a C-vector w.

  output: The fraction of row labels r of A such that
  the sign of (row r of A) * w differs from that of b[r]
  """
예제 #12
0
                                                       for r in range(m)
                                                       for c in range(n)})


def sps2sparseMat(M):
    S = M.tolil()
    elems = {(i, S.rows[i][j]): S.data[i][j]
             for i in range(len(S.data)) for j in range(len(S.data[i]))}
    return (sparse_Mat((set(range(S.shape[0])), set(range(S.shape[1]))),
                       elems))


if __name__ == '__main__':
    a = np.random.randint(10, 20, (1000))
    b = np.random.randint(10, 20, (1000))
    c = vec.Vec(a.tolist())
    d = vec.Vec(b.tolist())

    add_numpy(a, b)
    add_vec(c, d)

    M = np.random.randint(10, 20, (30, 10))
    N = np.random.randint(10, 20, (10, 30))
    u = np.random.randint(10, 20, (30))
    v = np.random.randint(10, 20, (10))

    mult_numpy(M, v)
    mult_mat(mat.Mat(M.tolist()), vec.Vec(v.tolist()))

    mult_numpy(u, M)
    mult_mat(vec.Vec(u.tolist()), mat.Mat(M.tolist()))
예제 #13
0
파일: reper_gl.py 프로젝트: yfyh2013/cbox
def draw( self, api ):
    cols = [ (1,0,0), (0,1,0), (0,0,1) ]
    for v,c in zip( self, cols ):
        api.line( vec.Vec( 0,0,0 ), v, c )
예제 #14
0
import draw_gl as dg

from OpenGL.GL import *
from OpenGL.GLU import *
from OpenGL.GLUT import *


def draw(self, api):
    # save old state and load identity matrix
    if self.opt['style'] is 'dot':
        api.sphere(self,
                   self.opt['r'],
                   self.opt['color'],
                   invis=self.opt['invis'])

    if self.opt['style'] is 'line':
        api.line(self.opt['start'], self, self.opt['color'])


import vec
vec.Vec.draw = draw
vec.Vec.opt = {
    'style': 'dot',
    'r': 0.3,
    'color': (0.8, 0.8, 0.8),
    'invis': False,
    'start': vec.Vec(0, 0, 0)
}