def test_earth_moon_loop(self):
"""Test that moon loops over Earth."""
moon = dot.Dot()
moon.mass = constants.MOON.MASS
moon.pos[0] = constants.MOON.PERIGEE_ORBIT_RADIUS
init_moon_pos = numpy.array(moon.pos)
moon.vel[1] = constants.MOON.MAX_ORBITAL_VELOCITY
earth = dot.Dot()
earth.mass = constants.EARTH.MASS
# Set system inertion to 0
earth.vel[
1] = -constants.MOON.MAX_ORBITAL_VELOCITY * moon.mass / earth.mass
test_space = space.Space(dots=[earth, moon])
# Distance between moon initial position and position after loop
min_distance = numpy.inf
n_loops = 4.
n_iterations = 10000
t = 0
dt = n_loops * constants.MOON.SIDEREAL_ROTATION_PERIOD / n_iterations
for iteration in range(n_iterations):
test_space.step(time=dt)
t += dt
if t > constants.MOON.SIDEREAL_ROTATION_PERIOD / 2:
min_distance = min(
min_distance,
space.Space.distance(init_moon_pos, moon.pos),
)
assert min_distance < constants.MOON.RADIUS / 100, "Moon not reached init position."
def test_roof_and_floor(self):
left_pillar = [dot.Dot([2, 2]), dot.Dot([3, 2])]
right_pillar = [dot.Dot([2, 3]), dot.Dot([3, 3])]
roof, floor = self.mygrid.roof_and_floor(left_pillar, right_pillar)
self.assertEqual(roof[0], left_pillar[0])
self.assertEqual(roof[1], right_pillar[0])
self.assertEqual(floor[0], left_pillar[1])
self.assertEqual(floor[0], left_pillar[1])
def test_pillar_lines(self):
roof = [dot.Dot([1, 2]), dot.Dot([1, 3])]
floor = [dot.Dot([2, 2]), dot.Dot([2, 3])]
left_pillar, right_pillar = self.mygrid.pillar_lines(roof, floor)
self.assertEqual(roof[0], left_pillar[0])
self.assertEqual(roof[1], right_pillar[0])
self.assertEqual(floor[0], left_pillar[1])
self.assertEqual(floor[0], left_pillar[1])
def test_simple_earth_gravity(self):
"""Test gravitational acceleration at Earth surface near 9.8 m/s^2."""
earth = dot.Dot()
earth.mass = constants.EARTH.MASS
simple_dot = dot.Dot()
simple_dot.pos[0] = constants.EARTH.RADIUS
test_space = space.Space(dots=[earth, simple_dot])
test_space.step_acceleration()
assert math.isclose(simple_dot.acc[0], -9.8, abs_tol=0.01)
def __init__(self, starting_pos, goal_pos, gen_size=50, movement_size=1, num_survivors=10):
self.size = gen_size
self.movement_size = movement_size
self.dots = []
self.starting_pos = starting_pos.copy()
self.goal_pos = goal_pos.copy()
self.x_move_stats = []
self.y_move_stats = []
self.best_num = num_survivors
self.prev_bests = []
for i in range(self.best_num):
self.prev_bests.append(Dot.Dot(x_pos=starting_pos[0], y_pos=starting_pos[1]))
for i in range(gen_size):
self.dots.append(Dot.Dot(starting_pos[0], starting_pos[1]))
def test_is_horizontal(self):
self.assertFalse(
self.mygrid.is_horizontal([dot.Dot([0, 0]),
dot.Dot([1, 0])]))
self.assertTrue(
self.mygrid.is_horizontal([dot.Dot([0, 0]),
dot.Dot([0, 1])]))
self.assertTrue(
self.mygrid.is_horizontal([dot.Dot([3, 2]),
dot.Dot([3, 3])]))
self.assertFalse(
self.mygrid.is_horizontal([dot.Dot([3, 3]),
dot.Dot([2, 3])]))
self.assertTrue(
self.mygrid.is_horizontal([dot.Dot([2, 2]),
dot.Dot([2, 1])]))
def test_dot_below(self):
self.assertEqual(self.mygrid.dot_below(dot.Dot([0, 1])),
dot.Dot([1, 1]))
self.assertIsNone(self.mygrid.dot_below(dot.Dot([3, 3])))
self.assertEqual(self.mygrid.dot_below(dot.Dot([2, 2])),
dot.Dot([3, 2]))
self.assertEqual(self.mygrid.dot_below(dot.Dot([1, 3])),
dot.Dot([2, 3]))
self.assertIsNone(self.mygrid.dot_below(dot.Dot([3, 0])))
def test_dot_above(self):
self.assertEqual(self.mygrid.dot_above(dot.Dot([1, 1])),
dot.Dot([0, 1]))
self.assertIsNone(self.mygrid.dot_above(dot.Dot([0, 3])))
self.assertEqual(self.mygrid.dot_above(dot.Dot([3, 0])),
dot.Dot([2, 0]))
self.assertEqual(self.mygrid.dot_above(dot.Dot([2, 2])),
dot.Dot([1, 2]))
self.assertIsNone(self.mygrid.dot_above(dot.Dot([0, 0])))
def test_dot_to_left_of(self):
self.assertEqual(self.mygrid.dot_to_left_of(dot.Dot([0, 1])),
dot.Dot([0, 0]))
self.assertIsNone(self.mygrid.dot_to_left_of(dot.Dot([0, 0])))
self.assertEqual(self.mygrid.dot_to_left_of(dot.Dot([2, 2])),
dot.Dot([2, 1]))
self.assertEqual(self.mygrid.dot_to_left_of(dot.Dot([3, 1])),
dot.Dot([3, 0]))
self.assertIsNone(self.mygrid.dot_to_left_of(dot.Dot([3, 0])))
def test_dot_to_right_of(self):
self.assertEqual(self.mygrid.dot_to_right_of(dot.Dot([0, 1])),
dot.Dot([0, 2]))
self.assertIsNone(self.mygrid.dot_to_right_of(dot.Dot([0, 3])))
self.assertEqual(self.mygrid.dot_to_right_of(dot.Dot([3, 2])),
dot.Dot([3, 3]))
self.assertEqual(self.mygrid.dot_to_right_of(dot.Dot([0, 0])),
dot.Dot([0, 1]))
self.assertIsNone(self.mygrid.dot_to_right_of(dot.Dot([3, 3])))
def test_not_adjacent(self):
self.assertFalse(
self.mygrid.not_adjacent(dot.Dot([1, 2]), dot.Dot([2, 2])))
self.assertTrue(
self.mygrid.not_adjacent(dot.Dot([2, 2]), dot.Dot([2, 2])))
self.assertFalse(
self.mygrid.not_adjacent(dot.Dot([2, 1]), dot.Dot([3, 1])))
self.assertTrue(
self.mygrid.not_adjacent(dot.Dot([1, 1]), dot.Dot([2, 2])))
def __init__(self, x1, y1, w):
print "ALine.__init__"
self._x = x1
self._y = y1
self._w = w
self._controls = {}
self._dot = dot.Dot(self._x, self._y, 0)
self._num_triangles = 100
def drawCurvyArrow(ctx, startPos, endPos, middlePos, cust):
if type(cust) is DictType: cust = dot.Dot(cust)
if not middlePos:
middlePos = [((startPos[0] + endPos[0]) / 2,
(startPos[1] + endPos[1]) / 2)]
ctx.save()
ctx.set_source_rgba(*cust.color)
ctx.set_line_width(cust.lineThickness)
# We don't want the curvy arrow's line to lay over the beginning button
buttonRadius = cust.get("buttonRadius", 4)
if buttonRadius: # so go a few pixels in the correct direction
lv = lineVector(startPos, middlePos[0])
sp = (startPos[0] + lv[0] * (buttonRadius - .05),
startPos[1] + lv[1] * (buttonRadius - .05))
else:
sp = startPos
# Calculate the arrow at the end of the line
(a, b) = calcArrow(middlePos[0][0], middlePos[0][1], endPos[0], endPos[1],
cust.arrowLength, cust.arrowAngle)
# We don't want the line to overlap the arrow at the end of it, so
# calculate a new endpoint for the line by finding the midpoint of the back of the arrow
ep = ((a[0] + b[0]) / 2, (a[1] + b[1]) / 2)
ctx.move_to(*sp)
try:
ctx.curve_to(middlePos[0][0], middlePos[0][1], middlePos[0][0],
middlePos[0][1], ep[0], ep[1])
except:
pdb.set_trace()
ctx.stroke()
ctx.set_line_width(
.1
) # These will be filled, so set the containing line width to be invisibly thin
if buttonRadius:
ctx.arc(startPos[0], startPos[1], cust.buttonRadius, 0,
2 * 3.141592637)
ctx.close_path()
ctx.stroke_preserve()
ctx.set_source_rgba(cust.color[0], cust.color[1], cust.color[2],
cust.color[3])
ctx.fill()
# Draw the arrow on the end
ctx.set_source_rgba(*cust.color)
ctx.move_to(endPos[0], endPos[1])
ctx.line_to(*a)
ctx.line_to(*b)
ctx.close_path()
ctx.stroke_preserve()
ctx.fill()
ctx.restore()
def generate_dot(dotgroup, window_size, config):
ek = lambda p: dotgroup[p] if p in dotgroup else (
ep(dotgroup['template'][p], config)
if p in dotgroup['template'] else None)
args = {
i: ek(i)
for i in
['loc', 'radius', 'color', 'period', 'phase', 'duty', 'motile']
if ek(i) != None
}
args['window_size'] = window_size
args['loc'] = [ep(i, config) for i in args['loc']]
return dot.Dot(**args)
def __init__(self, gameWorld, startpos, size):
"""
Creat a bunch of dots.
"""
self.dots = []
self.gworld = gameWorld
self.startpos = startpos
self.size = size
self.fitnesssum = 0
self.generation = 1
self.bestdot = 0
self.maxsteps = 400
for _ in range(size):
self.dots.append(dot.Dot(self.gworld, self.startpos))
def TestCreate(name):
"""Internal module unit test"""
import aspAmfCreate
import dot
s = Session()
n = s.GetRunningAmfNodes()
ent = aspAmfCreate.CreateApp(name,n,dot.Dot({"rModel":"2N"}),[{"key":"value"}])
s.InstallEntities(ent)
s.InstallCsiConfig(ent)
s.InstallCompConfig(ent)
s.InstallNodeConfig(ent)
s.InstallSgConfig(ent)
s.InstallSiConfig(ent)
s.InstallSuConfig(ent)
s.Startup((ServiceGroupType,name + "SGi0"))
s.Startup((ServiceUnitType,name + "SUi0_1"))
def __init__(self,
color=(0, 0, 0, .9),
circleRadius=5,
linethickness=4,
arrowlen=15,
arrowangle=PI / 8):
Gesture.__init__(self)
wx.Timer.__init__(self)
self.cust = dot.Dot()
self.cust.color = color
self.cust.buttonRadius = circleRadius
self.cust.lineThickness = linethickness
self.cust.arrowLength = arrowlen
self.cust.arrowAngle = arrowangle
self.downPos = self.curPos = None
self.center = None
self.frameInterval = 10 # Targeted milliseconds between frame redraws
self.frameAverage = self.frameInterval # Actual (measured) milliseconds between redraws
self.lastFrame = None # When the last Notify occurred
self.settleTime = 250.0 # How long in milliseconds should the line take to straighten
def test_update_list_of_drawn_lines_with(self):
self.mygame.list_of_lines_drawn = [[dot.Dot([0, 0]),
dot.Dot([0, 1])],
[dot.Dot([0, 2]),
dot.Dot([0, 3])],
[dot.Dot([2, 2]),
dot.Dot([3, 2])],
[dot.Dot([1, 2]),
dot.Dot([1, 3])]]
self.mygame.update_list_of_drawn_lines_with(
[dot.Dot([2, 0]), dot.Dot([1, 0])])
self.assertNotIn([dot.Dot([2, 0]), dot.Dot([1, 0])],
self.mygame.list_of_lines_drawn)
self.assertIn([dot.Dot([1, 0]), dot.Dot([2, 0])],
self.mygame.list_of_lines_drawn)
self.mygame.update_list_of_drawn_lines_with(
[dot.Dot([2, 3]), dot.Dot([2, 2])])
self.assertNotIn([dot.Dot([2, 3]), dot.Dot([2, 2])],
self.mygame.list_of_lines_drawn)
self.assertIn([dot.Dot([2, 2]), dot.Dot([2, 3])],
self.mygame.list_of_lines_drawn)
def test_is_rightmost(self):
self.assertFalse(self.mygrid.is_rightmost(dot.Dot([1, 1])))
self.assertFalse(self.mygrid.is_rightmost(dot.Dot([0, 0])))
self.assertTrue(self.mygrid.is_rightmost(dot.Dot([3, 3])))
self.assertTrue(self.mygrid.is_rightmost(dot.Dot([2, 3])))
self.assertTrue(self.mygrid.is_rightmost(dot.Dot([0, 3])))
def init(data, doorMap):
data.bg = background.Background(goodBLUE)
data.boundary = outerWall.OuterWall(WHITE)
data.walls = allWalls.AllWalls(doorMap, WHITE)
data.dot = dot.Dot(60, 60, doorMap)
start_end.start(data.dot)
def main(isToCut):
title_window = ''
def on_trackbar(val):
alpha = val / alpha_slider_max
beta = (1.0 - alpha)
dst = cv2.addWeighted(src1, alpha, src2, beta, 0.0)
cv2.imshow(title_window, dst)
def nothing(x):
pass
#Argumentos do método 'face_cascade.detectMultiScale'(OBS.: está bom para uma curta distância)
# scaleFactor = 1.06
# minNeighbors = 50
scaleFactor = 1.3
minNeighbors = 5
name = "Hey dboa man?"
#name1 = "ihoi"
#folder = "new_imgs"
#bar = ["right eye:", "left eye:"]
bar_name = "value of trackbar eye:"
#count = 0
cam = cv2.VideoCapture(0)
cam.set(cv2.CAP_PROP_FPS, 30)
limite = 0
#importa o classificador de face
face_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_frontalface_default.xml')
#importa o classificador de olho
eye_cascade = cv2.CascadeClassifier('haarcascades/haarcascade_eye.xml')
#Iniciando o algoritmo Blob
blob_parm = cv2.SimpleBlobDetector_Params()
blob_parm.filterByArea = True
blob_parm.maxArea = 1500 #unidade em pixels
blob_dt = cv2.SimpleBlobDetector_create(blob_parm)
#Desenha as barras deslizantes na janela
cv2.namedWindow(name)
cv2.createTrackbar(bar_name, name, 0, 255, nothing)
#Criando o ponto
obj = dot.Dot()
while(True):
ret, frame = cam.read()
#'''
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#aplica o algoritmo de detecção facial
faces = face_cascade.detectMultiScale(gray, scaleFactor, minNeighbors)
#Direito
#Esquerdo
#cv2.createTrackbar(bar[1], name, 0, 255, nothing)
if cv2.waitKey(1) == ord('o'):
for i in range(10):
obj.move_dot()
#letra 'q'
if cv2.waitKey(1) == ord('q'):
obj.exit_window()
break
for (x,y,w,h) in faces:
cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray = gray[y:y+h, x:x+w]
roi_color = frame[y:y+h, x:x+w]
cv2.GaussianBlur(roi_gray, (3, 3), 0.005 * (w*h))
#aplica o algoritmo de detecção do olho
eyes = eye_cascade.detectMultiScale(roi_gray)
for i in range(len(eyes)):
(ex,ey,ew,eh) = eyes[i]
if ey < 1/2*(y+h) - 100:
cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
try:
limite = cv2.getTrackbarPos(bar_name, name)
except IndexError:
print("Há mais de um elemento na cena que está atrapalhando a detecção do usuário. Try Again Pls :)")
eye_img = roi_color[ey:ey+eh, ex:ex+ew]
if isToCut:
eye_img = ce.cut_eyebrows(eye_img)
#cutImg.salveSubImg(0, 0, np.size(eye_img, 1), np.size(eye_img, 0), eye_img, count, folder)
keypoints = blob.blob_process(eye_img, blob_dt, limite)
cv2.drawKeypoints(eye_img, keypoints, eye_img, (0, 0, 255), cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS)
cv2.imshow("asdf",blob.img_blob_process(eye_img, blob_dt, limite, 1))
#cutImg.salveSubImg(ex, ey, ew, eh, roi_color, count)
#count+=1
#PROBLEMAS AQUI v
for i in keypoints:
if 30 > i.pt[0]:
print("left?")
else:
print("right?")
print(i.pt[0], end=' ')
print(i.pt[1])
#print(cv2.getTrackbarPos(bar_name, name) )
#cv2.imshow(name1, u)
cv2.imshow(name, frame)
#print(cam.get(cv2.CAP_PROP_FPS))
cam.release()
cv2.destroyWindow(name)
def make_first_pop(self):
for i in range(self.pop_size):
# dots are always added to the population and canvas, never removed
self.population.append(dot.Dot(self.canvas, self.brain_size))
# https://www.soundjay.com/beep-sounds-1.html
# Import and initialize the pygame library
import pygame
import dot
# Set up the drawing window
#pygame.mixer.pre_init(44100,16,2,4096)
pygame.init()
screen = pygame.display.set_mode([600, 600])
timer = pygame.time.Clock()
#effect = pygame.mixer.Sound('vinyl.wav') # set up the sound clip
# create a dot object
d1 = dot.Dot((255,500), (250,0))
d2 = dot.Dot((0,250), (500,250))
dots=[d1,d2]
sprites = pygame.sprite.Group()
sprites.add(d1)
sprites.add(d2)
# Fill the background with white
screen.fill((255, 255, 255))
#Run until the user asks to quit
running = True
while running:
# Did the user click the window close button?
if dot.Dot.sick_count < 0: dot.Dot.sick_count = 0
if dot.Dot.infected_count < 0: dot.Dot.infected_count = 0
if dot.Dot.immune_count < 0: dot.Dot.immune_count = 0
# Start of main code.
pygame.init()
screen = pygame.display.set_mode([750, 750])
timer = pygame.time.Clock()
### Dot creation.
while len(dots) < 100:
home = (random.randint(0,750),random.randint(0,750))
work = (random.randint(0,750),random.randint(0,750))
d = dot.Dot(home,work)
if negate_repeat() is False:
dots.append(d)
sprites.add(d)
random_immune()
random_sickness()
### Visuals and Game Logistics
screen.fill((255,255,255))
running = True
while running:
for event in pygame.event.get():
"Dead": (0, 0, 0) # Black
}
# Create Sprites
all_sprites_list = pygame.sprite.Group()
dotList = []
infection_origin = random.randint(75, 100)
# makes 25% not follow SIP and creates 90% of those who don't follow SIP
# follow SD6 and creates one dot that is infected and doesn't follow either
for i in range(100):
if i < 75:
start = (random.randint(0, 699), random.randint(0, 699))
end = (start[0], start[1])
state = "Healthy"
size = 5
dotObj = dot.Dot(start, end, state, size)
dotList.append(dotObj)
all_sprites_list.add(dotObj)
elif i == infection_origin:
start = (random.randint(0, 699), random.randint(0, 699))
end = (random.randint(0, 699), random.randint(0, 699))
state = "Infected"
size = 5
dotObj = dot.Dot(start, end, state, size, False, False)
dotList.append(dotObj)
all_sprites_list.add(dotObj)
elif i > 75 and i < 98:
start = (random.randint(0, 699), random.randint(0, 699))
end = (random.randint(0, 699), random.randint(0, 699))
state = "Healthy"
size = 5
def test_update_no_of_boxes_of_players(self):
self._quick_setup_boxes(0, 0)
boxes = [None, None]
self.mygame.update_no_of_boxes_of_players(0, boxes)
self.assertEqual(self.mygame.no_of_boxes_of_players[0], 0)
self.assertEqual(self.mygame.no_of_boxes_of_players[1], 0)
self.mygame.update_no_of_boxes_of_players(1, boxes)
self.assertEqual(self.mygame.no_of_boxes_of_players[0], 0)
self.assertEqual(self.mygame.no_of_boxes_of_players[1], 0)
self._quick_setup_boxes(3, 4)
boxes = [[[dot.Dot([0, 1]), dot.Dot([0, 2])],
[dot.Dot([0, 2]), dot.Dot([1, 2])],
[dot.Dot([1, 1]), dot.Dot([1, 2])],
[dot.Dot([0, 1]), dot.Dot([1, 1])]],
[[dot.Dot([0, 2]), dot.Dot([0, 3])],
[dot.Dot([1, 2]), dot.Dot([1, 3])],
[dot.Dot([0, 3]), dot.Dot([1, 3])],
[dot.Dot([0, 2]), dot.Dot([1, 2])]]]
self.mygame.update_no_of_boxes_of_players(0, boxes)
self.assertEqual(self.mygame.no_of_boxes_of_players[0], 4)
self.assertEqual(self.mygame.no_of_boxes_of_players[1], 4)
[box1, _] = boxes
self._quick_setup_boxes(4, 2)
self.mygame.update_no_of_boxes_of_players(1, [box1, None])
self.assertEqual(self.mygame.no_of_boxes_of_players[0], 4)
self.assertEqual(self.mygame.no_of_boxes_of_players[1], 3)
import dot
import time
to = time.time()
print("Time init: ", to)
obj = dot.Dot()
while True:
if obj.EventMovement():
obj.move_dot()
print("Tempo percorrido até o click(s): ", time.time()-to)
if obj.isToClose():
break
obj.exit_window()
def setUp(self):
self.rows = 4
self.cols = 4
self.no_of_players = 2
self.mygame = game.Game([self.rows, self.cols], self.no_of_players)
# Position shown in figure 1)
self.list_of_lines_drawn = [
[dot.Dot([0, 0]), dot.Dot([0, 1])],
[dot.Dot([1, 1]), dot.Dot([2, 1])],
[dot.Dot([3, 0]), dot.Dot([3, 1])],
[dot.Dot([3, 1]), dot.Dot([3, 2])],
[dot.Dot([3, 2]), dot.Dot([3, 3])],
[dot.Dot([1, 3]), dot.Dot([2, 3])],
[dot.Dot([1, 2]), dot.Dot([1, 3])],
[dot.Dot([0, 0]), dot.Dot([1, 0])],
[dot.Dot([0, 3]), dot.Dot([1, 3])],
[dot.Dot([2, 2]), dot.Dot([3, 2])],
[dot.Dot([2, 3]), dot.Dot([3, 3])],
[dot.Dot([1, 2]), dot.Dot([2, 2])],
]
import matplotlib
matplotlib.rcParams['text.usetex'] = True
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy
import constants
import dot
import space
if __name__ == '__main__':
earth = dot.Dot()
earth.mass = constants.EARTH.MASS
moon = dot.Dot()
moon.mass = constants.MOON.MASS
moon.pos[0] = constants.MOON.PERIGEE_ORBIT_RADIUS
moon.vel[1] = constants.MOON.MAX_ORBITAL_VELOCITY
moon.vel[2] = 20
earth.vel[
1] = -constants.MOON.MAX_ORBITAL_VELOCITY * moon.mass / earth.mass
test_space = space.Space(dots=[earth, moon])
print()
print(test_space)
n_loops = 3
n_iterations = 1000
results = numpy.zeros(shape=(n_iterations, 12))
def test_box_formed_by(self):
nonelist = [None, None]
boxes = [[[dot.Dot([1, 2]), dot.Dot([1, 3])],
[dot.Dot([1, 3]), dot.Dot([2, 3])],
[dot.Dot([2, 2]), dot.Dot([2, 3])],
[dot.Dot([1, 2]), dot.Dot([2, 2])]],
[[dot.Dot([2, 2]), dot.Dot([2, 3])],
[dot.Dot([2, 3]), dot.Dot([3, 3])],
[dot.Dot([3, 2]), dot.Dot([3, 3])],
[dot.Dot([2, 2]), dot.Dot([3, 2])]]]
self._quick_check_box(
self.list_of_lines_drawn,
[dot.Dot([2, 2]), dot.Dot([2, 3])], boxes, True)
self._quick_check_box(
[], [dot.Dot([0, 0]), dot.Dot([0, 1])], nonelist, False)
self._quick_check_box(
[[dot.Dot([0, 0]), dot.Dot([0, 1])],
[dot.Dot([1, 0]), dot.Dot([0, 0])],
[dot.Dot([0, 1]), dot.Dot([1, 1])],
[dot.Dot([3, 0]), dot.Dot([3, 1])]],
[dot.Dot([1, 0]), dot.Dot([1, 1])], nonelist, False)
self._quick_check_box(
[[dot.Dot([0, 0]), dot.Dot([0, 1])],
[dot.Dot([1, 0]), dot.Dot([0, 0])],
[dot.Dot([0, 1]), dot.Dot([1, 1])],
[dot.Dot([3, 0]), dot.Dot([3, 1])]],
[dot.Dot([1, 0]), dot.Dot([1, 1])], nonelist, False)
