def _process_trace(self, t, reverse=False):
l1 = len(t.trace)
l2 = len(t.trace[0])
swap_groups = []
cols_used = set()
for i in range(l1 - 1):
prev_row = -1
for j in range(l2 - 1):
if t.trace[i][j]:
if prev_row != i:
if j not in cols_used:
if reverse:
grp = Transformation([t.s2[i]], [t.s1[j]])
cols_used.add(j)
else:
grp = Transformation([t.s1[j]], [t.s2[i]])
cols_used.add(j)
swap_groups.append(grp)
prev_row = i
else:
if reverse:
grp = Transformation([t.s1[j]], [])
else:
grp = Transformation([], [t.s2[i]])
swap_groups.append(grp)
prev_row = i
else:
if reverse:
swap_groups[len(swap_groups) - 1].right.append(
t.s1[j])
else:
swap_groups[len(swap_groups) - 1].left.append(
t.s1[j])
return swap_groups
def main():
if len(sys.argv) != 3:
print('Error: Execution -> python3 main.py <url> <name_database>')
exit(1)
url = sys.argv[1]
name_db = sys.argv[2]
transformation = Transformation(url=url,
output_path='databases/',
name_db=name_db)
transformation.transformation()
load = Load(transformation.new_engine)
load.load(output_path='excel/')
def fix_spr(self, spr_obj):
"""
Sprite fixes, such as color and transparency issues
"""
spr_obj[0] = Transformation.resize(spr_obj)
spr_obj[0] = spr_obj[0].convert_alpha()
return spr_obj
def updateNode(self, camera):
s = Transformation.fromData("scale", (self.scaleX, self.scaleY))
#FIXME: WHY THE MINUS HERE?
r = Transformation.fromData("rotate", (self.rotation,))
t = Transformation.fromData("translate", (self.x, self.y))
a = self.__anchor
ia = inv(self.__anchor)
tb = (t * s * r * ia).translationAfter
n = self.__node
n.set('x', str(tb.x))
n.set('y', str(tb.y))
n.set('transform', (s*r).toCss())
def __init__(self):
self.vicon_lists = []
self.vicon_ts = []
self.vicon_x = []
self.vicon_y = []
self.vicon_z = []
self.vicon_qw = []
self.vicon_qx = []
self.vicon_qy = []
self.vicon_qz = []
self.opti_lists = []
self.opti_ts = []
self.opti_x = []
self.opti_y = []
self.opti_z = []
self.opti_qw = []
self.opti_qx = []
self.opti_qy = []
self.opti_qz = []
self.opti_orig_lists = [
] # Original (i.e., opti to wand) before transformation
self.opti_orig_ts = []
self.opti_orig_x = []
self.opti_orig_y = []
self.opti_orig_z = []
self.opti_orig_qw = []
self.opti_orig_qx = []
self.opti_orig_qy = []
self.opti_orig_qz = []
self.T_ts = []
self.T_x = []
self.T_y = []
self.T_z = []
self.T_qw = []
self.T_qx = []
self.T_qy = []
self.T_qz = []
self.T_vicon_to_opti_positions = []
self.T_vicon_to_opti_quats = []
self.T_obj = Transformation()
def test_all_equation_substitutions_addition_by_same(self):
equation = Parser.parse_equation('3.0 = (x)+(x)')
substitution = ExpressionSubstitution(Parser.parse_expression('a + a'),
Parser.parse_expression('2*a'))
transformation = Transformation.apply_all_substitution_transformations(
substitution)
result = transformation.apply(equation)
verify(str(result), self.reporter)
def demo():
image = request.files['sample.jpg']
stream = image.stream
name = image.name
print(name)
img_array = np.asarray(bytearray(stream.read()), dtype=np.uint8)
img = cv2.imdecode(img_array, 1)
path = './tmp/' + name
cv2.imwrite(path, img)
print("demo------------6")
return_name = Transformation.transform(name)
# return send_from_directory('./transformed', name)
return jsonify({'data': return_name})
def test_all_equation_substitutions_simple(self):
equation = Parser.parse_equation('y = (x)-(x)')
substitution = ExpressionSubstitution(Parser.parse_expression('a - a'),
Parser.parse_expression('0'))
transformation = Transformation.apply_all_substitution_transformations(
substitution)
result = transformation.apply(equation)
verify(str(result), self.reporter)
def animate_cfg(cfg: ConfigFile, identity=False):
corr_markers = cfg.markers # List of vertex-tuples (source, target)
if identity:
corr_markers = np.ascontiguousarray(
np.array((corr_markers[:, 0], corr_markers[:, 0]), dtype=np.int).T)
original_source = meshlib.Mesh.load(cfg.source.reference)
original_target = meshlib.Mesh.load(cfg.target.reference)
if identity:
original_target = meshlib.Mesh.load(cfg.source.reference)
mapping = get_correspondence(original_source, original_target,
corr_markers)
transf = Transformation(original_source,
original_target,
mapping,
smoothness=1)
animate(transf, list(cfg.source.load_poses()))
def api_image():
count = 0
image = request.files['sample.jpg']
stream = image.stream
name = str(count) + '_' + image.name
print(name)
path = os.path.join(app.config['UPLOAD_FOLDER'], name)
img_array = np.asarray(bytearray(stream.read()), dtype=np.uint8)
print("------------1")
img = cv2.imdecode(img_array, 1)
cv2.imwrite(path, img)
print("------------2")
# print(url_for(url_path))
return_name = Transformation.transform(name)
# return redirect(url_for(uploaded_file(name)))
count = count + 1
# return send_from_directory('./resized', return_name)
return send_from_directory('./resized', "hoge_resize.jpg")
def __init__(self, canvas, id, distance=None, width=None, height=None, **params):
self.__canvas = canvas
self.__id = id
self.__node = canvas.loadSvgNode(id)
# first set distance
print id, self.__node
if distance is not None:
self.__distance = distance
elif width is not None:
Transformation.fromCss(self.__node.get("transform",""))
raise Exception("NYI")
#self.__distance = ...
elif height is not None:
Transformation.fromCss(self.__node.get("transform",""))
raise Exception("NYI")
#self.__distance = ...
else:
raise ValueError("At least one of distance, width or height must be set.")
# find gravity
gx = float(self.__node.get("width"))/2
gy = float(self.__node.get("height"))/2
#gx = 0
#gy = 0
self.__anchor = Transformation.fromData("translate", (gx, gy))
# get transformation data from xml node
x = float(self.__node.get("x",0))
y = float(self.__node.get("y",0))
t1 = Transformation.fromCss(self.__node.get("transform",""))
#t2 = self.__anchor * Transformation.fromData("translate", (x,y)) * t1
t2 = Transformation.fromData("translate", (x,y)) * t1 * self.__anchor
#print "Before:", t2.translationBefore.x, t2.translationBefore.y
#print "After :", t2.translationAfter.x, t2.translationAfter.y
# apply local transformation data
self.x = t2.translationBefore.x
self.y = t2.translationBefore.y
self.rotation = t2.rotation.beta
self.scaleX = t2.scale.sx
self.scaleY = t2.scale.sy
print (self.x, self.y)
def dimetricXZ(self):
Transformation.dimetricXZ(self)
return {"x": self.x, "y": self.y, "z": self.z}
def trimetricZ(self):
Transformation.trimetricZ(self)
return {"x": self.x, "y": self.y, "z": self.z}
def isometric(self):
Transformation.isometric(self)
return {"x": self.x, "y": self.y, "z": self.z}
def oblique(self):
Transformation.oblique(self)
return {"x": self.x, "y": self.y, "z": self.z}
def translationY(self, number):
Transformation.matrixTranslationY(number, self)
return {"x": self.x, "y": self.y, "z": self.z}
def shearY(self, number):
Transformation.matrixShearY(number, self)
return {"x": self.x, "y": self.y, "z": self.z}
def __init__(self, dataSource, dataSet):
trans_obj = Transformation(dataSource, dataSet)
class Data(object):
def __init__(self):
self.vicon_lists = []
self.vicon_ts = []
self.vicon_x = []
self.vicon_y = []
self.vicon_z = []
self.vicon_qw = []
self.vicon_qx = []
self.vicon_qy = []
self.vicon_qz = []
self.opti_lists = []
self.opti_ts = []
self.opti_x = []
self.opti_y = []
self.opti_z = []
self.opti_qw = []
self.opti_qx = []
self.opti_qy = []
self.opti_qz = []
self.opti_orig_lists = [
] # Original (i.e., opti to wand) before transformation
self.opti_orig_ts = []
self.opti_orig_x = []
self.opti_orig_y = []
self.opti_orig_z = []
self.opti_orig_qw = []
self.opti_orig_qx = []
self.opti_orig_qy = []
self.opti_orig_qz = []
self.T_ts = []
self.T_x = []
self.T_y = []
self.T_z = []
self.T_qw = []
self.T_qx = []
self.T_qy = []
self.T_qz = []
self.T_vicon_to_opti_positions = []
self.T_vicon_to_opti_quats = []
self.T_obj = Transformation()
def add_vicon_data(self, data):
self.vicon_lists.append(data)
def add_opti_data(self, data):
self.opti_lists.append(data)
def add_opti_orig_data(self, data):
self.opti_orig_lists.append(data)
def set_vicon(self):
self.vicon_ts = np.asarray([data[0] for data in self.vicon_lists])
self.vicon_x = np.asarray([data[1] for data in self.vicon_lists])
self.vicon_y = np.asarray([data[2] for data in self.vicon_lists])
self.vicon_z = np.asarray([data[3] for data in self.vicon_lists])
self.vicon_qw = np.asarray([data[4] for data in self.vicon_lists])
self.vicon_qx = np.asarray([data[5] for data in self.vicon_lists])
self.vicon_qy = np.asarray([data[6] for data in self.vicon_lists])
self.vicon_qz = np.asarray([data[7] for data in self.vicon_lists])
def set_opti(self):
self.opti_ts = np.asarray([data[0] for data in self.opti_lists])
self.opti_x = np.asarray([data[1] for data in self.opti_lists])
self.opti_y = np.asarray([data[2] for data in self.opti_lists])
self.opti_z = np.asarray([data[3] for data in self.opti_lists])
self.opti_qw = np.asarray([data[4] for data in self.opti_lists])
self.opti_qx = np.asarray([data[5] for data in self.opti_lists])
self.opti_qy = np.asarray([data[6] for data in self.opti_lists])
self.opti_qz = np.asarray([data[7] for data in self.opti_lists])
def set_opti_orig(self):
self.opti_orig_ts = np.asarray(
[data[0] for data in self.opti_orig_lists])
self.opti_orig_x = np.asarray(
[data[1] for data in self.opti_orig_lists])
self.opti_orig_y = np.asarray(
[data[2] for data in self.opti_orig_lists])
self.opti_orig_z = np.asarray(
[data[3] for data in self.opti_orig_lists])
self.opti_orig_qw = np.asarray(
[data[4] for data in self.opti_orig_lists])
self.opti_orig_qx = np.asarray(
[data[5] for data in self.opti_orig_lists])
self.opti_orig_qy = np.asarray(
[data[6] for data in self.opti_orig_lists])
self.opti_orig_qz = np.asarray(
[data[7] for data in self.opti_orig_lists])
def find_nearest_idx(self, array, value):
idx = (np.abs(array - value)).argmin()
return idx
def diff(self, value_1, value_2):
return np.absolute(value_1 - value_2)
def optimize_T(self):
for vicon_idx in range(len(self.vicon_ts)):
opti_idx = self.find_nearest_idx(self.opti_ts,
self.vicon_ts[vicon_idx])
x_diff = self.diff(self.vicon_x[vicon_idx], self.opti_x[opti_idx])
y_diff = self.diff(self.vicon_y[vicon_idx], self.opti_y[opti_idx])
z_diff = self.diff(self.vicon_z[vicon_idx], self.opti_z[opti_idx])
qw_diff = self.diff(np.absolute(self.vicon_qw[vicon_idx]),
np.absolute(self.opti_qw[opti_idx]))
qx_diff = self.diff(np.absolute(self.vicon_qx[vicon_idx]),
np.absolute(self.opti_qx[opti_idx]))
qy_diff = self.diff(np.absolute(self.vicon_qy[vicon_idx]),
np.absolute(self.opti_qy[opti_idx]))
qz_diff = self.diff(np.absolute(self.vicon_qz[vicon_idx]),
np.absolute(self.opti_qz[opti_idx]))
if x_diff <= 0.03 and y_diff <= 0.03 and z_diff <= 0.03 and \
qw_diff <= 0.03 and qx_diff <= 0.03 and qy_diff <= 0.03 and qz_diff <= 0.03:
# T_vicon_to_wand
T_vicon_to_wand = self.T_obj.convert_to_T_matrix(
position=np.array([
self.vicon_x[vicon_idx], self.vicon_y[vicon_idx],
self.vicon_z[vicon_idx]
]),
quat=np.array([
self.vicon_qw[vicon_idx], self.vicon_qx[vicon_idx],
self.vicon_qy[vicon_idx], self.vicon_qz[vicon_idx]
]))
# T_opti_to_wand
T_opti_to_wand = self.T_obj.convert_to_T_matrix(
position=np.array([
self.opti_orig_x[opti_idx], self.opti_orig_y[opti_idx],
self.opti_orig_z[opti_idx]
]),
quat=np.array([
self.opti_orig_qw[opti_idx],
self.opti_orig_qx[opti_idx],
self.opti_orig_qy[opti_idx],
self.opti_orig_qz[opti_idx]
]))
# T_wand_to_opti
T_wand_to_opti = self.T_obj.inverse_matrix(T_opti_to_wand)
# T_vicon_to_opti
T_vicon_to_opti = np.dot(T_vicon_to_wand, T_wand_to_opti)
T_vicon_to_opti_position, T_vicon_to_opti_quat = \
self.T_obj.convert_T_matrix_to_position_and_quat(T_vicon_to_opti)
print 'T_vicon_to_opti: \nPos (x y z): {}\nQuat (w x y z): {}'.format(
T_vicon_to_opti_position, T_vicon_to_opti_quat)
# Save result
self.T_vicon_to_opti_positions.append(T_vicon_to_opti_position)
self.T_vicon_to_opti_quats.append(T_vicon_to_opti_quat)
# Add data for visualization
self.T_ts.append(self.opti_ts[opti_idx])
self.T_x.append(self.opti_x[opti_idx])
self.T_y.append(self.opti_y[opti_idx])
self.T_z.append(self.opti_z[opti_idx])
self.T_qw.append(self.opti_qw[opti_idx])
self.T_qx.append(self.opti_qx[opti_idx])
self.T_qy.append(self.opti_qy[opti_idx])
self.T_qz.append(self.opti_qz[opti_idx])
print len(self.T_vicon_to_opti_positions)
print np.mean(self.T_vicon_to_opti_positions, axis=0)
print np.mean(self.T_vicon_to_opti_quats, axis=0)
def error(self):
x_err = []
y_err = []
z_err = []
qx_err = []
qy_err = []
qz_err = []
qw_err = []
self.vicon_ts = self.vicon_ts[::5]
self.vicon_x = self.vicon_x[::5]
self.vicon_y = self.vicon_y[::5]
self.vicon_z = self.vicon_z[::5]
self.vicon_qw = self.vicon_qw[::5]
self.vicon_qx = self.vicon_qx[::5]
self.vicon_qy = self.vicon_qy[::5]
self.vicon_qz = self.vicon_qz[::5]
self.opti_ts = self.opti_ts[::5]
self.opti_x = self.opti_x[::5]
self.opti_y = self.opti_y[::5]
self.opti_z = self.opti_z[::5]
self.opti_qw = self.opti_qw[::5]
self.opti_qx = self.opti_qx[::5]
self.opti_qy = self.opti_qy[::5]
self.opti_qz = self.opti_qz[::5]
for vicon_idx in range(len(self.vicon_ts)):
print vicon_idx, '/', len(self.vicon_ts)
opti_idx = self.find_nearest_idx(self.opti_ts,
self.vicon_ts[vicon_idx])
if self.diff(self.vicon_ts[vicon_idx],
self.opti_ts[opti_idx]) < 0.1:
x_err.append(
self.diff(self.vicon_x[vicon_idx], self.opti_x[opti_idx]))
y_err.append(
self.diff(self.vicon_y[vicon_idx], self.opti_y[opti_idx]))
z_err.append(
self.diff(self.vicon_z[vicon_idx], self.opti_z[opti_idx]))
qw_err.append(
self.diff(self.vicon_qw[vicon_idx],
-self.opti_qw[opti_idx]))
qx_err.append(
self.diff(self.vicon_qx[vicon_idx],
-self.opti_qx[opti_idx]))
qy_err.append(
self.diff(self.vicon_qy[vicon_idx],
-self.opti_qy[opti_idx]))
qz_err.append(
self.diff(self.vicon_qz[vicon_idx],
-self.opti_qz[opti_idx]))
print np.mean(x_err)
print np.mean(y_err)
print np.mean(z_err)
print np.mean(qw_err)
print np.mean(qx_err)
print np.mean(qy_err)
print np.mean(qz_err)
def scale(self, escala):
Transformation.scale(escala, self)
return {"x": self.x, "y": self.y, "z": self.z}
return args
if __name__ == '__main__':
# v_args = GetArgs()
# v_input_file_type = v_args.input_file_type
v_input_file_type = "csv"
# Import Data : class get_data
obj_get_data = getdata()
source_df = obj_get_data.ReadCSVData()
# Transformation : class transformation
obj_transformation = Transformation(source_df)
obj_transformation.set_time_readable()
obj_transformation.set_medium_source_path()
top_source_medium_df = obj_transformation.final_dataframe()
#v_name = top_source_medium_df.
print(top_source_medium_df)
distinctusers_batch = obj_transformation.execute_metrics(10000)
print(distinctusers_batch)
distinctusers_day = obj_transformation.calc_distinctusers_perday()
print(distinctusers_day)
# Save Output based on required format
obj_SaveOutput = SaveOutput(top_source_medium_df, 'top_source_medium')
obj_SaveOutput.save_data()
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
if __name__ == '__main__':
strings_list = sys.argv
if len(strings_list) < 2:
print("Please pass in at least one argument")
exit()
action = f"{strings_list[1]}"
output_format = ""
if len(strings_list) >= 3:
output_format = f"{strings_list[2]}"
transformation = Transformation(output_format)
if action.lower().strip() == "device_tahmo_mapping":
transformation.map_devices_to_tahmo_station()
elif action.lower().strip() == "site_tahmo_mapping":
transformation.map_sites_to_tahmo_station()
elif action.lower().strip() == "sites_without_a_primary_device":
transformation.get_sites_without_a_primary_device()
elif action.lower().strip() == "missing_devices_on_bigquery":
transformation.get_devices_not_up_to_date_on_big_query()
elif action.lower().strip() == "update_primary_devices":
transformation.update_primary_devices()
def generateActions(self, world, market):
finish = False
actions = []
untradeable_resources = [
'R1', 'R4', 'R7', 'R19', 'R21', 'R22', "R1'", "R5'", "R6'", "R18'",
"R19'", "R20'", "R21'", "R22'", "cash"
]
while not finish:
print("Awaiting command: ")
string = str(input())
tokens = string.split()
command = tokens[0].lower()
if command == "buy":
if len(tokens) < 3:
print("Missing parameters")
else:
ticker = tokens[1].upper()
if ticker in untradeable_resources:
print("Cannot buy " + ticker)
else:
orders = []
for i in range(2, len(tokens)):
order = tokens[i].split(",")
content = {}
strike = float(order[0])
content["strike"] = strike
quantity = int(order[1])
content["quantity"] = quantity
if len(order) >= 3:
expiration = int(order[2])
content["expiration"] = expiration
orders.append(content)
transaction = Transaction(self.name, "buy",
{ticker: orders}, market)
actions.append(transaction)
print("Submitted:")
print(transaction.toString())
elif command == "sell":
if len(tokens) < 3:
print("Missing parameters")
else:
ticker = tokens[1].upper()
if ticker in untradeable_resources:
print("Cannot sell " + ticker)
else:
orders = []
for i in range(2, len(tokens)):
order = tokens[i].split(",")
content = {}
strike = float(order[0])
content["strike"] = strike
quantity = int(order[1])
content["quantity"] = quantity
if len(order) >= 3:
expiration = int(order[2])
content["expiration"] = expiration
orders.append(content)
transaction = Transaction(self.name, "sell",
{ticker: orders}, market)
actions.append(transaction)
print("Submitted:")
print(transaction.toString())
elif command == "show":
if len(tokens) > 1:
flag = tokens[1].lower()
if flag == "-w":
print("World State:", world)
elif flag == "-m":
market.printOrderBook()
elif flag == "-t":
if len(tokens) < 3:
print("Missing parameters")
else:
tickers = tokens[2].split(",")
for i in range(0, len(tickers)):
ticker = tickers[i].upper()
print(ticker, market.quotePrice(ticker))
elif flag == "-tm":
print("housing:", housing)
print("alloys:", alloys)
print("electronics:", electronics)
print("farms:", farms)
print("factories:", factories)
print("metallic_elements:", metallic_elements)
print("timber:", timber)
print("plant:", plant)
else:
print("Illgeal flag")
else:
print("My State:", world[self.name])
elif command == "mine":
if len(tokens) < 3:
print("missing parameters")
else:
resource = tokens[1].upper()
difficulty = int(tokens[2])
mine = Mine(self, resource, difficulty)
print("Submitted: ", mine.toString())
actions.append(mine)
elif command == "transform":
if len(tokens) < 3:
print("missing parameters")
else:
t = tokens[1].lower()
multiplier = int(tokens[2])
template = ""
if t == "housing":
template = housing
if t == "alloys":
template = alloys
if t == "electronics":
template = electronics
if t == "farms":
template = farms
if t == "factories":
template = factories
if t == "metallic_elements":
template = metallic_elements
if t == "timber":
template = timber
if t == "plant":
template = plant
if template:
transformation = Transformation(
self.name, template, multiplier)
print("Submitted: ", transformation.toString())
actions.append(transformation)
else:
print("Illegal template")
# Congratulations! You have found the easter egg!
elif command == "greedisgood":
money = 5000
if len(tokens) >= 2:
money = float(tokens[1])
world[self.name]["cash"] = world[self.name]["cash"] + money
print("You gave yourself " + str(money) + " cash. Go crazy!")
elif command == "end":
finish = True
elif command == "help":
print("Here's a list of the commands: ")
print("1. show [-w] [-m] [-t (t1,t2,t3...)] [-tm]")
print(
"2. buy (ticker) (strike1,quantity1,[expiration1]) (strike2,quantity2,[expiration2]) ..."
)
print(
"3. sell (ticker) (strike1,quantity1,[expiration1]) (strike2,quantity2,[expiration2]) ..."
)
print("4. mine (resource) (difficulty)")
print("5. transform (template) (multiplier)")
print("6. end")
else:
print("Illegal command")
print()
return actions
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
