def Equaliterality(AAAB14):
""" Calculates the Equaliterality of the Tetrahedra.
Specific for Ion Environments project. """
Data = []
Head = AAAB14[0]
Tail = AAAB14[1:]
L1 = GetInd(Head, 'L1')
L2 = GetInd(Head, 'L2')
L4 = GetInd(Head, 'L4')
SStruct = GetInd(Head, 'SStruct')
Head.insert(SStruct, 'Equilaterality')
Data.append(Head)
for item in Tail:
A = dc(item[L1])
B = dc(item[L2])
C = dc(item[L4])
# print A, B, C
Mn = (A + B + C) / dc(3)
SqMn = Mn**2
AA = (A - B)**2
BB = (A - C)**2
CC = (B - C)**2
Num = AA + BB + CC
Den = dc(3) * SqMn
ans = Num / Den
Equa = round(ans, 4)
item.insert(SStruct, str(Equa))
# print (item)
Data.append(item)
return Data
def Height(AAAB14):
""" Calculates the Height of Tetrahedra.
Specific for Ion Environments project. """
Data = []
Head = AAAB14[0]
Tail = AAAB14[1:]
L1 = GetInd(Head, 'L1')
L2 = GetInd(Head, 'L2')
L4 = GetInd(Head, 'L4')
Vl = GetInd(Head, 'Volume')
SStruct = GetInd(Head, 'SStruct')
Head.insert(SStruct, 'Height')
Data.append(Head)
for item in Tail:
A = dc(item[L1])
B = dc(item[L2])
C = dc(item[L4])
Vol = dc(item[Vl])
S = (A + B + C) / dc(2)
SA = S - A
SB = S - B
SC = S - C
a = (S * (SA * SB * SC))
area = numpy.sqrt(a)
ht = (3 * Vol) / area
Height = round(ht, 4)
item.insert(SStruct, str(Height))
Data.append(item)
return Data
def return_B(K, m):
muller = gamma(-1 + ((2j * math.pi * m) / math.log(2)))
multiplier_real = dc(muller.real)
multiplier_imag = dc(muller.imag)
A_real, A_img = return_A(K, m)
term_real = (multiplier_real * A_real) - (multiplier_imag * A_img)
term_img = (multiplier_imag * A_real) + (multiplier_real * A_img)
return term_real, term_img
def parse_player(self, response):
try:
g, h, w = response.css(
"span:nth-child(5) .entry-crumb , .row-2 .column-2 , .row-3 .column-2"
).xpath("text()").extract()
n = response.css('p:nth-child(4)').xpath('text()').extract_first()
h = h.split()
w = int(w.split()[0])
except ValueError as v:
g = response.css("span:nth-child(5) .entry-crumb").xpath(
"text()").extract_first()
n = response.xpath(
'//p[preceding-sibling::h3/strong[text()="Born Name"]]/text()'
).extract_first()
h = response.xpath(
'//p[preceding-sibling::h3/strong[text()="Height"]]/text()'
).extract_first()
w = response.xpath(
'//p[preceding-sibling::h3/strong[text()="Weight"]]/text()'
).extract_first()
h = h.split('or')[0].split()
w = int(w.split('or')[0].split()[0])
if 'ft' in h:
hi = dc(int(h[0])) * 12
if 'in' in h:
if not h[-2][-1].isdigit():
h[-2] = float(h[-2][:-1]) + numeric(h[-2][-1])
hi += dc(h[-2])
h = round(dc(hi) * dc(2.54), 2)
if 'male' or 'female' in g.lower():
g = g.split()[0]
# id of the player
i = response.url.split('/')[-1]
# url
url = response.url
print("====================>", self.count)
yield {
'id': i,
'name': n,
'gender': g,
'height': h,
'weight': w,
'url': url
}
def TriangleArea(A, B, C):
""" Calculates area of a triangle
using lengths of sides as input."""
A, B, C = dc(A), dc(B), dc(C)
S = (A + B + C) / 2
SA = S - A
SB = S - B
SC = S - C
a = (S * (SA * SB * SC))
area = numpy.sqrt(a)
Area = round(area, 4)
return Area
def results(self, times='all', t_precision=12, **kwargs):
r"""
Fetches the calculated quantity from the algorithm and returns it as
an array.
Parameters
----------
times : scalar or list
Time steps to be returned. The default value is 'all' which results
in returning all time steps. If a scalar is given, only the
corresponding time step is returned. If a range is given
(e.g., 'range(0, 1, 1e-3)'), time steps in this range are returned.
t_precision : integer
The time precision (number of decimal places). Default value is 12.
Notes
-----
The keyword steps is interpreted in the same way as times.
"""
if 'steps' in kwargs.keys():
times = kwargs['steps']
t_pre = t_precision
quantity = self.settings['quantity']
q = [k for k in list(self.keys()) if quantity in k]
if times == 'all':
t = q
elif type(times) in [float, int]:
n = int(-dc(str(round(times, t_pre))).as_tuple().exponent *
(round(times, t_pre) != int(times)))
t_str = (str(int(round(times, t_pre) * 10**n)) + ('e-' + str(n)) *
(n != 0))
t = [k for k in q if t_str == k.split('@')[-1]]
elif 'range' in times:
t = times.replace(' ', '')
t = t[6:-1]
t = t.split(',')
out = np.arange(float(t[0]), float(t[1]), float(t[2]))
out = np.append(out, float(t[1]))
out = np.unique(out)
out = np.around(out, decimals=t_pre)
t = []
for i in out:
n = int(-dc(str(round(i, t_pre))).as_tuple().exponent *
(round(i, t_pre) != int(i)))
j = (str(int(round(i, t_pre) * 10**n)) + ('e-' + str(n)) *
(n != 0))
t_str = [k for k in q if j == k.split('@')[-1]]
t += (t_str)
d = {k: self[k] for k in t}
return d
def get_account_value(selected_account, all_assets):
account_value = all_assets.aggregate(
Sum('value'))['value__sum'] or dc(0.00)
selected_account.value = account_value
selected_account.save()
return account_value
def new_asset(request, account_id):
if request.method == "POST":
asset_form = NewAssetForm(request.POST)
if asset_form.is_valid():
account = AssetAccount.objects.get(pk=account_id)
asset = asset_form.save(commit=False)
stock = yf.Ticker(
asset.ticker) #exception for if not a valid stock
asset.price = stock.info['currentPrice']
asset.value = dc(asset.price) * asset.shares
asset.account = account
asset.save()
updated_assets = Asset.objects.filter(account=account)
history = AccountHistory.objects.get(account=account)
history.value = get_account_value(account, updated_assets)
history.save()
return redirect(
reverse('finance_app:account-detail',
kwargs={'account_id': account_id}))
else:
asset_form = NewAssetForm()
return render(request, 'finance_app/asset_new.html',
{'asset_form': asset_form})
def budget_dashboard(request):
try: #need a test for this
expenses = latest_months_expenses()
except ObjectDoesNotExist:
expenses = Expense.objects.none()
total_transactions = Transaction.objects.all().aggregate(
Sum('inflow'))['inflow__sum'] or dc(0.00)
total_allocations = expenses.aggregate(
Sum('allocated'))['allocated__sum'] or dc(0.00)
unbudgeted = total_transactions - total_allocations
context = {
'expenses': expenses,
'unbudgeted': unbudgeted,
}
return render(request, 'budget_app/dashboard.html', context)
def min_max_points(df):
diff_lwx = np.diff(split_leftwrist_x(df))
diff_rwx = np.diff(split_rightwrist_x(df))
diff_lwy = np.diff(split_leftwrist_y(df))
diff_rwy = np.diff(split_rightwrist_y(df))
x = [diff_lwx, diff_lwy, diff_rwx, diff_rwy]
min_max = []
for i in x:
l = len(i)
j = 0
while j < l:
min1 = fc.minimum(i[j:j + math.ceil(l / 3)])
max1 = fc.minimum(i[j:j + math.ceil(l / 3)])
dev = dc(max1) - dc(min1)
min_max.append(dev)
j = j + math.ceil(l / 3)
return pd.DataFrame(min_max).transpose()
def SumSA(AAAB14):
""" Calculates the Surface Area of the Tetrahedra.
Specific for the Ion Environments Project. """
Data = []
Head = AAAB14[0]
Tail = AAAB14[1:]
ta1 = GetInd(Head, 'Triangle1')
ta2 = GetInd(Head, 'Triangle2')
ta3 = GetInd(Head, 'Triangle3')
ta4 = GetInd(Head, 'Triangle4')
SStruct = GetInd(Head, 'SStruct')
Head.insert(SStruct, 'Simplex_SurfArea')
Data.append(Head)
for item in Tail:
A, B, C, D = dc(item[ta1]), dc(item[ta2]), dc(item[ta3]), dc(item[ta4])
Sum = (A + B + C + D)
Sum = round(Sum, 4)
item.insert(SStruct, str(Sum))
Data.append(item)
return Data
def MACDR2Test(pricesData, macd, signalLine):
periods = getTradingPeriods(macd, signalLine)
profitRateList = []
successList = []
for period in periods:
totalTrade = getTotalTradesInAPeriod(pricesData, macd, signalLine,
period)
if totalTrade is not None:
profitRate = totalTrade.getProfitRate(pricesData)
profitRateList.append(profitRate)
if profitRate > 0:
successList.append(1)
else:
successList.append(0)
if len(profitRateList) > 0:
return np.mean(successList), np.mean(profitRateList)
else:
#return None, None
return dc(0), dc(0)
def Triangle4(AAAB14):
""" Calculates the Area of the Triangle.
Specific for Ion Environments project."""
Data = []
Head = AAAB14[0]
Tail = AAAB14[1:]
L1 = GetInd(Head, 'L1')
L3 = GetInd(Head, 'L2')
L5 = GetInd(Head, 'L4')
SStruct = GetInd(Head, 'SStruct')
Head.insert(SStruct, 'Triangle4')
Data.append(Head)
for item in Tail:
A = dc(item[L1])
B = dc(item[L3])
C = dc(item[L5])
Area = TriangleArea(A, B, C)
# print (Area)
item.insert(SStruct, str(Area))
Data.append(item)
return Data
def AvgTF(AAAB14):
""" Calculates the Average of Temperature Factors.
Specific for Ion Environments project. """
Data = []
Head = AAAB14[0]
Tail = AAAB14[1:]
# First get Index and then insert into header
TF1 = GetInd(Head, 'TF1')
TF2 = GetInd(Head, 'TF2')
TF3 = GetInd(Head, 'TF3')
TF4 = GetInd(Head, 'TF4')
SStruct = GetInd(Head, 'SStruct')
Head.insert(SStruct, 'AvgTF')
Data.append(Head)
for item in Tail:
A, B, C, D = dc(item[TF1]), dc(item[TF2]), dc(item[TF3]), dc(item[TF4])
Avg = (A + B + C + D) / dc(4.0)
Avg = round(Avg, 4)
item.insert(SStruct, str(Avg))
Data.append(item)
return Data
def _update_settings_and_docs(self, dc):
if isinstance(dc, type): # If dc is class then instantiate it
dc = dc()
self.__doc__ = dc.__doc__
# if dc is a dataclass object. This step is only necessary to support
# Python 3.6 which doesn't have the dataclasses module
if hasattr(dc, '__dict__'):
dc = copy.deepcopy(dc.__dict__)
else:
dc = copy.deepcopy(dc)
for item in dc.keys():
self[item] = dc[item]
def update_stock_values(account_id):
account_to_update = AssetAccount.objects.get(pk=account_id)
account_assets = Asset.objects.filter(account=account_to_update)
value_list = []
for a in account_assets:
s = yf.Ticker(a.ticker).info['currentPrice']
a.price = s
a.value = a.shares * dc(a.price)
value_list.append(a.value)
a.save()
account_to_update.value = sum(value_list)
account_to_update.save()
def _nbr_to_str(self, nbr, t_pre=None):
r"""
Converts a scalar into a string in scientific (exponential) notation
without the decimal point.
Parameters
----------
nbr : scalar
The number to be converted into a scalar.
t_precision : integer
The time precision (number of decimal places). Default value is 12.
"""
if t_pre is None:
t_pre = self.settings['t_precision']
n = int(-dc(str(round(nbr, t_pre))).as_tuple().exponent *
(round(nbr, t_pre) != int(nbr)))
nbr_str = (str(int(round(nbr, t_pre)*10**n)) + ('e-'+str(n))*(n != 0))
return nbr_str
def nbr_to_str(nbr, t_precision):
r"""
Converts a scalar into a string in scientific (exponential) notation
without the decimal point.
Parameters
----------
nbr : scalar
The number to be converted into a scalar.
t_precision : integer
The time precision (number of decimal places). Default value is 12.
"""
from decimal import Decimal as dc
n = int(-dc(str(round(nbr, t_precision))).as_tuple().exponent *
(round(nbr, t_precision) != int(nbr)))
nbr_str = (str(int(round(nbr, t_precision) * 10**n)) + ('e-' + str(n)) *
(n != 0))
return nbr_str
def _nbr_to_str(self, nbr, t_pre=None):
r"""
Converts a scalar into a string in scientific (exponential) notation
without the decimal point.
Parameters
----------
nbr : scalar
The number to be converted into a scalar.
t_precision : integer
The time precision (number of decimal places). Default value is 12.
"""
if t_pre is None:
t_pre = self.settings['t_precision']
n = int(-dc(str(round(nbr, t_pre))).as_tuple().exponent *
(round(nbr, t_pre) != int(nbr)))
nbr_str = (str(int(round(nbr, t_pre) * 10**n)) + ('e-' + str(n)) *
(n != 0))
return nbr_str
def Omega(AAAB14):
""" Calculates the Solid Angle Omega for the Vertex that represents
the HETATM.
Specific for Ion Environments project. """
Data = []
Head = AAAB14[0]
Tail = AAAB14[1:]
L1 = GetInd(Head, 'L1')
L2 = GetInd(Head, 'L2')
L3 = GetInd(Head, 'L3')
L4 = GetInd(Head, 'L4')
L5 = GetInd(Head, 'L5')
L6 = GetInd(Head, 'L6')
SStruct = GetInd(Head, 'SStruct')
Head.insert(SStruct, 'Omega')
Data.append(Head)
for item in Tail:
l1 = dc(item[L1])
l2 = dc(item[L2])
l3 = dc(item[L3])
l4 = dc(item[L4])
l5 = dc(item[L5])
l6 = dc(item[L6])
# print (l1, l2, l3, l4, l5, l6)
try:
A = ((l5**2) + (l6**2) - (l4**2))
a = (2 * l5 * l6)
A = acos(A / a)
B = ((l5**2) + (l3**2) - (l1**2))
b = (2 * l5 * l3)
B = acos(B / b)
C = ((l6**2) + (l3**2) - (l2**2))
c = (2 * l3 * l6)
C = acos(C / c)
S = (A + B + C) / 2.0
val = tan(S / 2) * tan((S - A) / 2) * tan((S - B) / 2) * tan(
(S - C) / 2)
if val <= 0:
val = abs(val)
except ValueError:
val = 0
omega = sqrt(val)
omega = 4 * atan(omega)
Omega = degrees(omega)
Omega = round(omega, 4)
item.insert(SStruct, str(Omega))
Data.append(item)
return Data
def AAAB14(listFilePaths, ion_abbr, HeadList, NewList, OutLocDataFile,
OutLocCountFile):
""" Returns a list of lists where the vertex is AAAB abd the edge lengths
are less than or equal to 14 A.
Specific for Ion Environments project. """
AAAB14 = []
Counts = []
for item in listFilePaths:
entry = item.split('/')
entry = entry[-1]
pdbid = entry[0:4]
chain = entry[5]
dotloc = entry.index('.')
pdbid_het = entry[0:dotloc]
L1 = (HeadList.index('L1'))
L2 = (HeadList.index('L2'))
L3 = (HeadList.index('L3'))
L4 = (HeadList.index('L4'))
L5 = (HeadList.index('L5'))
L6 = (HeadList.index('L6'))
Fh = open(item, "r")
lines = [i.strip() for i in Fh.readlines()]
lineCount = 0
AAABCount = 0
AAAB14Count = 0
for line in lines:
lineCount = lineCount + 1
if "AAAB" in line:
AAABCount = AAABCount + 1
line = line.split()
if (dc(line[L1]) <= 14.00) and (dc(line[L2]) <= 14.00) and (dc(
line[L3]) <= 14.00) and (dc(line[L4]) <= 14.00) and (
dc(line[L5]) <= 14.00) and (dc(line[L6]) <= 14.00):
line.insert(0, pdbid_het)
AAAB14Count = AAAB14Count + 1
AAAB14.append(line)
Fh.close()
Cnt_List = [pdbid_het, lineCount, AAABCount, AAAB14Count]
Counts.append(Cnt_List)
AAAB14.insert(0, NewList)
Counts.insert(0, ["PDBID", "Line_Count", "AAABCount", "AAAB14Count"])
List_to_CSV(AAAB14, OutLocDataFile)
List_to_CSV(Counts, OutLocCountFile)
return AAAB14
def return_A(K, m):
imag_comp = dc((2 * math.pi * m) / math.log(2))
prod_real = dc(-(imag_comp * imag_comp))
prod_imag = dc(-imag_comp)
outer_k_sum_real = dc(1)
outer_k_sum_imag = dc(0)
for k in range(1, K + 1):
prod_real_temp = prod_real
prod_img_temp = prod_imag
for i in range(1, k - 1):
prod_real = (prod_real_temp * i) - (prod_img_temp * imag_comp)
prod_imag = (prod_img_temp * i) + (prod_real_temp * imag_comp)
denom = dc(math.factorial(k))
prod_div_real = (prod_real / denom)
prod_div_imag = (prod_imag / denom)
outer_k_sum_real += prod_div_real
outer_k_sum_imag += prod_div_imag
return outer_k_sum_real, outer_k_sum_imag
def make_commision(self, amount, order):
tota_com = (amount * Commision_Rate) / 100
# count = 0
# user = self.parent if self.parent else None
# for i in range(Limit_Upline):
# if user is None:
# break
# count += 1
com = tota_com / Limit_Upline
user = self.parent if self.parent else None
for i in range(Limit_Upline):
if user is None:
break
wallet, created = Wallet.objects.get_or_create(user=user)
if not WalletHistory.objects.filter(wallet=wallet,
order=order).exists():
wh = WalletHistory(wallet=wallet,
order=order,
prev_bal=wallet.bal,
amount=com)
wallet.bal += dc(com)
wh.save()
wallet.save()
user = user.parent
def save(self, commit=True):
m = super(RequestForm, self).save(commit=False)
if commit:
m.user.profile.bal += dc(self.cleaned_data['amount'])
m.save()
return m
class PaymentRequest(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
date = models.DateField(validators=[OnlyPast], verbose_name='Payment Date')
amount = models.DecimalField(max_digits=10, decimal_places=0, validators=[MinValueValidator(dc(1000))], verbose_name='Request For Amount')
type = models.PositiveSmallIntegerField(choices=PAYMENT_MODE, verbose_name='Payment Mode')
deposit = models.ForeignKey(Bank, on_delete=models.CASCADE, verbose_name='Deposit Bank Name')
ref = models.CharField(max_length=255, verbose_name='Bank Ref Number')
remarks = models.TextField(null=True, blank=True)
status = models.PositiveSmallIntegerField(choices=REQUEST_STATUS, default=1)
dt = models.DateTimeField(auto_now_add=True)
def get_update_url(self):
return reverse_lazy('trans:update_request', kwargs={'pk': self.pk})
print("Now I will count the eggs:")
# 鸡蛋有7个
print("Eggs", 3 + 2 + 1 - 5 + 4 % 2 - 1 / 4 + 6)
print("Is it true that 3+2<5-7?")
print("Is it true that 3+2<5-7?", 3 + 2 < 5 - 7)
print("What is 3 + 2?", 3 + 2)
print("What is 5 - 7?", 5 - 7)
# 哦，这就是为什么它是假的。
print("Oh, that's why it's False.")
# 再来点
print("How about some more.")
print("Is it greater?", 5 > -2)
print("Is it greater or equal?", 5 >= -2)
print("Is it less or equal?", 5 <= -2)
# Study Drills
print(float(3 + 2 + 1 - 5 + 4 % 3 - 1 / 4 + 6))
print(float(10 / 3))
# 十六进制整数41
print(float(0x41))
# 八进制整数41
print(float(0o41))
# 二进制整数1101
print(float(0b1101))
# 保留20位小数
print('%.20f' % (4 / 3))
# 保留4位小数
from decimal import Decimal as dc
print(dc('5.026').quantize(dc('0.0000')))
print 'oct(997), hex(997) :', (oct(997), hex(997))
print "int('0100'), int('0100', 8), int('0x40', 16) :", (int('0100'), int('0100', 8), int('0x40', 16))
print '997 / 19 =', 997 / 19
print '997 % 19 =', 997 % 19
print '997 // 19 =', 997 // 19
print
# math 模块
print '【math 模块】'
import math
print 'math.pi =', math.pi
print 'math.e =', math.e
print 'math.sin(math.pi / 6) =', math.sin(math.pi / 6)
print 'mmath.sqrt(2) =', math.sqrt(2)
print
# random 模块
print '【random 模块】'
import random
print "random.random() =", random.random()
print "random.randint(1, 10) =", random.randint(1, 10)
print "random.randint(1, 10) =", random.choice(['LiXue', 'ChangXingYe', 'XueJiaJia', 'GuoNa'])
print
# 小数数字
print '【小数数字】'
print ' 0.1 + 0.1 + 0.1 - 0.3 =', 0.1 + 0.1 + 0.1 - 0.3
from decimal import Decimal as dc
print "dc('0.1') + dc('0.1') + dc('0.1') - dc('0.3') =", dc('0.1') + dc('0.1') + dc('0.1') - dc('0.3')
print
def _run_transient(self, t):
"""r
Performs a transient simulation according to the specified settings
updating 'b' and calling '_t_run_reactive' at each time step.
Stops after reaching the end time 't_final' or after achieving the
specified tolerance 't_tolerance'. Stores the initial and steady-state
(if obtained) fields in addition to transient data (according to the
specified 't_output').
Parameters
----------
t : scalar
The time to start the simulation from.
Notes
-----
Transient solutions are stored on the object under
``pore.quantity_timeStepIndex`` where *quantity* is specified in the
``settings`` attribute. Initial field is stored as
``pore.quantity_initial``. Steady-state solution (if reached) is stored
as ``pore.quantity_steady``. Current solution is stored as
``pore.quantity``.
"""
tf = self.settings['t_final']
dt = self.settings['t_step']
to = self.settings['t_output']
tol = self.settings['t_tolerance']
t_pre = self.settings['t_precision']
s = self.settings['t_scheme']
res_t = 1e+06 # Initialize the residual
if not isinstance(to, list):
# Make sure 'tf' and 'to' are multiples of 'dt'
tf = tf + (dt - (tf % dt)) * ((tf % dt) != 0)
to = to + (dt - (to % dt)) * ((to % dt) != 0)
self.settings['t_final'] = tf
self.settings['t_output'] = to
out = np.arange(t + to, tf, to)
else:
out = np.array(to)
out = np.append(out, tf)
out = np.unique(out)
out = np.around(out, decimals=t_pre)
if (s == 'steady'): # If solver in steady mode, do one iteration
logger.info(' Running in steady mode')
x_old = self[self.settings['quantity']]
self._t_run_reactive(x=x_old)
x_new = self[self.settings['quantity']]
else: # Do time iterations
# Export the initial field (t=t_initial)
n = int(-dc(str(round(t, t_pre))).as_tuple().exponent *
(round(t, t_pre) != int(t)))
t_str = (str(int(round(t, t_pre) * 10**n)) + ('e-' + str(n)) *
(n != 0))
quant_init = self[self.settings['quantity']]
self[self.settings['quantity'] + '@' + t_str] = quant_init
for time in np.arange(t + dt, tf + dt, dt):
if (res_t >= tol): # Check if the steady state is reached
logger.info(' Current time step: ' + str(time) + ' s')
x_old = self[self.settings['quantity']]
self._t_run_reactive(x=x_old)
x_new = self[self.settings['quantity']]
# Compute the residual
res_t = np.sum(np.absolute(x_old**2 - x_new**2))
logger.info(' Residual: ' + str(res_t))
# Output transient solutions. Round time to ensure every
# value in outputs is exported.
if round(time, t_pre) in out:
n = int(
-dc(str(round(time, t_pre))).as_tuple().exponent *
(round(time, t_pre) != int(time)))
t_str = (str(int(round(time, t_pre) * 10**n)) +
('e-' + str(n)) * (n != 0))
self[self.settings['quantity'] + '@' + t_str] = x_new
logger.info(' Exporting time step: ' +
str(time) + ' s')
# Update A and b and apply BCs
self._t_update_A()
self._t_update_b()
self._apply_BCs()
self._A_t = (self._A).copy()
self._b_t = (self._b).copy()
else: # Stop time iterations if residual < t_tolerance
# Output steady state solution
n = int(-dc(str(round(time, t_pre))).as_tuple().exponent *
(round(time, t_pre) != int(time)))
t_str = (str(int(round(time, t_pre) * 10**n)) +
('e-' + str(n)) * (n != 0))
self[self.settings['quantity'] + '@' + t_str] = x_new
logger.info(' Exporting time step: ' + str(time) +
' s')
break
if (round(time, t_pre) == tf):
logger.info(' Maximum time step reached: ' + str(time) +
' s')
else:
logger.info(' Transient solver converged after: ' +
str(time) + ' s')
#unimos la imagen original con la vista de eye bird
img_join = np.concatenate((img, img_eb_line), axis=1)
video_output.write(np.uint8(img_join))
#leemos la imagen correspondiente al siguiente frame
video_input_second = round(video_input_second + frame_rate, 2)
video_input.set(cv2.CAP_PROP_POS_MSEC, video_input_second*1000)
_ , img = video_input.read()
count = count + 1
points.clear()
#dibujamos los bounding box de la fila correspondiente al csv
cv2.rectangle(
img,
(dc(row["bl"]), dc(row["bt"])),
(dc(row["br"]), dc(row["bb"])),
_RECTANGLE_COLOR,
2)
#calculamos el centro del rectangulo para representar
#a una persona como punto
x = (dc(row["bl"]) + dc(row["br"]))/2
y = (dc(row["bt"]) + dc(row["bb"]))/2
#para este caso se aplico un relleno superior para ampliar
#la perspectiva por lo tanto se debe de actualizar la
#altura de los puntos
y = y + _HEIGHt_TOP_PADDING
points.append([x, y])
