def __init__(self):
self.sides = {
'L': Cube_side('L', "orange"),
'F': Cube_side('F', "green"),
'R': Cube_side('R', "red"),
'B': Cube_side('B', "blue"),
'U': Cube_side('U', "white"),
'D': Cube_side('D', "yellow")
}
self.turns = Rotate(self.sides)
def main():
rospy.init_node('main_node')
waits = lambda k: k.wait_for_cb()
move = lambda : waits(MovementManager(0.5))
rotate = lambda: waits(Rotate(get_angle()))
move_to_red = lambda: waits(MoveToRedObject(repeat=20))
funcs = [move, rotate, object_detector, move_to_red, move_arm]
stop = False
while not stop:
inp = prompt()
try:
clear()
choice = int(inp) - 1
(funcs[choice]())
continue
except ValueError:
if inp == 'q':
stop = True
continue
except IndexError:
pass
print('Invalid choice. try again')
def move_to_red(self):
"""
:param msg: msg of type Float32, distance from red object
"""
object_detector = ObjectDetector()
res = object_detector.get_distance_from_red_object()
if res is None:
rospy.loginfo("Red object was not detected")
return False
distance, angle = res
#if self.moving:
# self.force_close()
# return
#distance = msg.data
rospy.loginfo("distance from object : {}".format(distance/1000.0))
distance = max(0, distance/1000.0-self.MAX_DISTANCE_FROM_OBJECT-self.ARM_LENGTH)
rospy.loginfo("dis to red object : {}".format(distance))
if angle > 180:
angle = angle - 360
if abs(angle) > 8:
Rotate(0.5*angle).wait_for_cb()
self.moving=True
MovementManager(distance, obstacle_threshold=0.4, check_obstacles=True, threshold_direction=True).wait_for_cb()
return True
def main():
playTournament(
numOfGames=200,
players=[NN(),
Rotate(),
BeatPrevious(),
Probability(),
Conditional()])
import numpy as np
import argparse
import cv2
import PIL
import PIL.Image
import math
import imutils
import pytesseract
import os
from matplotlib import pyplot as plt
pytesseract.pytesseract.tesseract_cmd = 'C:/Program Files (x86)/Tesseract-OCR/tesseract'
ext = Extract()
fc = Findcontours()
tp = Textprocessing()
rs = Resize()
rot = Rotate()
rot90 = Rotate90()
class final:
def main(self, Input_image):
rotated = rot.rotateImage(Input_image)
bar = ext.barcode(rotated)
text = tp.nlp(bar)
rotated90 = rot90.rotateImage(Input_image)
bar90 = ext.barcode(rotated90)
text90 = tp.nlp(bar90)
if (
True
): #if(len(text)==0 and len(text90)==0): there might be IDs other than barcode ID too
res = rs.rsize(Input_image)
def Compare(crdnt1, crdnt2):
x1 = crdnt1[0]
y1 = crdnt1[1]
x2_1, y2_1 = Rotate(crdnt2)
return [x1 - x2_1, y1 - y2_1]
def run(self):
self.tracker1.getVideo(self.Video1)
self.tracker2.getVideo(self.Video2)
self.db.connect()
self._id = 0
self.idChecker = CamId()
while True:
if self.stopC == 1:
break
center1 = self.tracker1.trackFrame()
center2 = self.tracker2.trackFrame()
if center1 == -1 or center2 == -1:
break
if center1 == None:
scaledCenter = Transformation(
center2, self.trapezium.getTrapeziumBaseLarge(),
self.trapezium.getTrapeziumBaseSmall(),
self.trapezium.getTrapeziumHeight(),
self.trapezium.getZeroPointPosition())
self.center = Rotate(scaledCenter)
delta = None
self.camInd = "Вторая"
elif center2 == None:
scaledCenter = Transformation(
center1, self.trapezium.getTrapeziumBaseLarge(),
self.trapezium.getTrapeziumBaseSmall(),
self.trapezium.getTrapeziumHeight(),
self.trapezium.getZeroPointPosition())
self.center = scaledCenter
delta = None
self.camInd = "Первая"
else:
scaledCenter1 = Transformation(
center1, self.trapezium.getTrapeziumBaseLarge(),
self.trapezium.getTrapeziumBaseSmall(),
self.trapezium.getTrapeziumHeight(),
self.trapezium.getZeroPointPosition())
scaledCenter2 = Transformation(
center2, self.trapezium.getTrapeziumBaseLarge(),
self.trapezium.getTrapeziumBaseSmall(),
self.trapezium.getTrapeziumHeight(),
self.trapezium.getZeroPointPosition())
delta = Compare(scaledCenter1, scaledCenter2)
self.center = ([
int((scaledCenter1[0] + scaledCenter2[0]) / 2),
int((scaledCenter1[1] + scaledCenter2[1]) / 2)
])
delta = [int(delta[0]), int(delta[1])]
self.camInd = "Обе"
self.center = [int(self.center[0]), int(self.center[1])]
if not self.idChecker.isCurrent(self.center):
self._id = self._id + 1
self.GetNewCoordinatesInt.emit(self.center[0], self.center[1])
self.GetNewCoordinatesStr.emit("Позиция = " + str(self.center) +
" Камера: " + self.camInd +
" Объект: " + str(self._id))
self.db.vrite(self.center, delta, self.camInd, self._id)
if self.runIndicator != 1:
self.runIndicator = 1
self.db.commit()
self.db.disconnect()
self.tracker1.stop()
self.tracker2.stop()
if self.stopC != 0:
self.stopC = 0
if self.runIndicator != 0:
self.runIndicator = 0
from rotate import Rotate rotate=Rotate([1,3,5,7,8,9,10,12],2) rotate.leftrotateone()
class Cube:
def __init__(self):
self.sides = {
'L': Cube_side('L', "orange"),
'F': Cube_side('F', "green"),
'R': Cube_side('R', "red"),
'B': Cube_side('B', "blue"),
'U': Cube_side('U', "white"),
'D': Cube_side('D', "yellow")
}
self.turns = Rotate(self.sides)
def draw(self, x, y, size):
window = turtle.Screen()
turtle.speed(0)
turtle.pensize(2)
turtle.tracer(0, 0)
side_size = size * 3
self.sides['L'].draw_side(x, y, size)
self.sides['F'].draw_side(x + side_size, y, size)
self.sides['R'].draw_side(x + (2 * side_size), y, size)
self.sides['B'].draw_side(x + (3 * side_size), y, size)
self.sides['U'].draw_side(x + side_size, y + side_size, size)
self.sides['D'].draw_side(x + side_size, y - side_size, size)
turtle.hideturtle()
turtle.update()
def turn(self, operation):
rows = "U U' U2 U2' Uw u u' D D' D2 D2' Dw d d'B B'B2 B2' Bw b b' E E'"
column = "R R'R2 R2' Rw r r' L L'L2 L2' Lw l l' M M'"
special = "F F' F2 F2' Fw f f' B B'B2 B2' Bw b b' S S'"
if operation in rows:
self.turns.rows_operations(operation)
if operation in column:
self.turns.column_operations(operation)
if operation in special:
self.turns.special_operations(operation)
turtle.update()
def random_display(self, x, y, size, operations):
rows = "U U' U2 U2' Uw u u' D D' D2 D2' Dw d d'B B'B2 B2' Bw b b' E E'"
column = "R R'R2 R2' Rw r r' L L'L2 L2' Lw l l' M M'"
special = "F F' F2 F2' Fw f f' B B'B2 B2' Bw b b' S S'"
for i in range(15):
operation = random.choice(operations)
if operation in rows:
self.turns.rows_operations(operation)
if operation in column:
self.turns.column_operations(operation)
if operation in special:
self.turns.special_operations(operation)