def tbl_3_changed(self, row, col):
if not self.loaded: return
if self.tbl_3.verticalHeaderItem(row) is None: return
item = self.tbl_3.item(row, col)
if item is None: return
key = self.tbl_3.verticalHeaderItem(row).text()
if "flow units" in key.lower() or \
"headloss" in key.lower() or \
"unbalanced" in key.lower() or \
"status report" in key.lower():
# do nothing
pass
elif "maximum trials" in key.lower() or \
"default pattern" in key.lower() or \
"check freq" in key.lower() or \
"max check" in key.lower():
val, val_is_good = ParseData.intTryParse(item.text())
if val_is_good:
self.defaults.parameters_values[key] = val
else:
val, val_is_good = ParseData.floatTryParse(item.text())
if val_is_good:
self.defaults.parameters_values[key] = val
self.parameter_changed = True
pass
def set_CN(self):
props = []
for i in range(0, len(CurveNumberInfiltration.metadata)):
if "subcatch" in CurveNumberInfiltration.metadata[i].label.lower():
continue
elif "conduct" in CurveNumberInfiltration.metadata[i].label.lower():
continue
else:
props.append(CurveNumberInfiltration.metadata[i].label)
self.tblGeneric.setRowCount(len(props))
self.tblGeneric.setVerticalHeaderLabels(props)
#self.infil_model = CurveNumberInfiltration()
for i in range(0, self.tblGeneric.rowCount()):
vtitle = self.tblGeneric.verticalHeaderItem(i).text().lower()
if "curve" in vtitle:
val, val_is_good = ParseData.floatTryParse(self.defaults.infil_model_cn.curve_number)
if val_is_good:
self.tblGeneric.setItem(i,0, QtGui.QTableWidgetItem(unicode(val)))
else:
self.tblGeneric.setItem(i,0, QtGui.QTableWidgetItem(unicode(self.defaults.infil_model_cn.default_CN())))
elif "dry" in vtitle:
val, val_is_good = ParseData.floatTryParse(self.defaults.infil_model_cn.dry_days)
if val_is_good:
self.tblGeneric.setItem(i,0, QtGui.QTableWidgetItem(unicode(val)))
else:
self.tblGeneric.setItem(i,0, QtGui.QTableWidgetItem(unicode(self.defaults.infil_model_cn.default_dry_time())))
def GetData(self):
"""
construct pandas time series from grid data
Returns:
"""
del self.X[:] #datetime
del self.Y[:] #value
self.hour_only = True
if self.tblTime.item(0, 0):
if self.tblTime.item(0, 0).text():
self.hour_only = False
n = 0
ldate = ""
ltime = ""
for row in range(self.tblTime.rowCount()):
if self.tblTime.item(row, 2):
y_val, y_val_good = ParseData.floatTryParse(
self.tblTime.item(row, 2).text())
if y_val_good:
# as long as the value is good, then start parsing time stamp
self.Y.append(y_val)
if self.tblTime.item(row, 0):
if self.tblTime.item(row, 0).text():
ldate = self.tblTime.item(row, 0).text()
if self.tblTime.item(row, 1):
ltime, ltime_good = ParseData.floatTryParse(
self.tblTime.item(row, 1).text())
if ltime_good:
if self.tblTime.item(row, 1).text():
ltime = self.tblTime.item(row, 1).text()
if self.hour_only:
if ":" in ltime:
arr = ltime.split(":")
hr = 0
mm = 0
ss = 0
if len(arr) > 0:
hr = int(arr[0])
if len(arr) > 1:
mm = int(arr[1])
if len(arr) > 2:
ss = int(arr[2])
stamp = hr + mm / 60.0 + ss / 3600.0
else:
# if not in H:M format, then it is just fraction hours from beginning
stamp = float(ltime)
else:
stamp = pd.Timestamp(ldate + " " + ltime)
self.X.append(stamp)
n += 1
else:
return n
return n
def GetData(self):
n = 0
for row in range(self.tblMult.rowCount()):
if self.tblMult.item(row,0) and self.tblMult.item(row,1):
x_val, x_val_good = ParseData.floatTryParse(self.tblMult.item(row, 0).text())
y_val, y_val_good = ParseData.floatTryParse(self.tblMult.item(row, 1).text())
if x_val_good and y_val_good:
if row + 1 >= self.MAXPOINTS:
break
else:
self.X[row + 1] = x_val
self.Y[row + 1] = y_val
n += 1
else:
return n
return n
def set_from(self, project):
# section = core.swmm.options.dynamic_wave.DynamicWave()
section = project.options.dynamic_wave
if section.inertial_damping == core.swmm.options.dynamic_wave.InertialDamping.PARTIAL:
self.cboInertial.setCurrentIndex(1)
if section.inertial_damping == core.swmm.options.dynamic_wave.InertialDamping.FULL:
self.cboInertial.setCurrentIndex(2)
if section.inertial_damping == core.swmm.options.dynamic_wave.InertialDamping.NONE:
self.cboInertial.setCurrentIndex(0)
if section.force_main_equation == core.swmm.options.dynamic_wave.ForceMainEquation.H_W:
self.cboForce.setCurrentIndex(0)
if section.force_main_equation == core.swmm.options.dynamic_wave.ForceMainEquation.D_W:
self.cboForce.setCurrentIndex(1)
if section.normal_flow_limited == core.swmm.options.dynamic_wave.NormalFlowLimited.SLOPE:
self.cboNormal.setCurrentIndex(0)
if section.normal_flow_limited == core.swmm.options.dynamic_wave.NormalFlowLimited.FROUDE:
self.cboNormal.setCurrentIndex(1)
if section.normal_flow_limited == core.swmm.options.dynamic_wave.NormalFlowLimited.BOTH:
self.cboNormal.setCurrentIndex(2)
val, val_is_good = ParseData.intTryParse(section.threads)
if val_is_good:
self.cboThreads.setCurrentIndex(val - 1)
if float(section.variable_step) > 0:
self.cbxUseVariable.setChecked(True)
self.sbxAdjusted.setValue(float(section.variable_step) * 100)
self.txtMinimum.setText(str(section.minimum_step))
self.txtLengthening.setText(str(section.lengthening_step))
self.txtSurfaceArea.setText(str(section.min_surface_area))
self.txtTolerance.setText(str(section.head_tolerance))
self.sbxTrials.setValue(int(section.max_trials))
def set_from(self, project):
hydraulics_options = project.options.hydraulics
ui.convenience.set_combo(self.cboFlow, hydraulics_options.flow_units)
ui.convenience.set_combo(
self.cboHeadloss,
hydraulics_options.head_loss.name.replace('_', "-"))
self.txtAccuracy.setText(str(hydraulics_options.accuracy))
self.txtCheckFrequency.setText(str(hydraulics_options.check_frequency))
self.txtDampLimit.setText(str(hydraulics_options.damp_limit))
self.txtDefaultPattern.setText(str(hydraulics_options.default_pattern))
self.txtDemandMultiplier.setText(
str(hydraulics_options.demand_multiplier))
self.txtEmitterExponent.setText(
str(hydraulics_options.emitter_exponent))
self.txtMaxCheck.setText(str(hydraulics_options.max_check))
self.txtMaximumTrials.setText(str(hydraulics_options.maximum_trials))
self.txtRelativeViscosity.setText(str(hydraulics_options.viscosity))
self.txtSpecificGravity.setText(
str(hydraulics_options.specific_gravity))
if hydraulics_options.unbalanced == core.epanet.options.hydraulics.Unbalanced.STOP:
self.rbnStop.setChecked(True)
if hydraulics_options.unbalanced == core.epanet.options.hydraulics.Unbalanced.CONTINUE:
val, val_is_good = ParseData.intTryParse(
hydraulics_options.unbalanced_continue)
if not val_is_good:
val = 0
if val == 0:
self.rbnContinue.setChecked(True)
elif val > 0:
self.rbnContinueN.setChecked(True)
self.txtContinueN.setText(str(hydraulics_options.unbalanced_continue))
def GetData(self):
# construct pandas time series from grid data
del self.X[:]
del self.Y[:]
n = 0
for row in range(self.tblMult.rowCount()):
if self.tblMult.item(row, 1):
y_val, y_val_good = ParseData.floatTryParse(
self.tblMult.item(row, 1).text())
x_val, x_val_good = ParseData.floatTryParse(
self.tblMult.item(row, 0).text())
if y_val_good and x_val_good:
# as long as the values are good
self.Y.append(y_val)
self.X.append(x_val)
n += 1
else:
return n
return n
def load_curve_data(self):
directory = self._main_form.program_settings.value("DataDir", "")
file_name, ftype = QFileDialog.getOpenFileName(self,
"Open Curve Data File",
directory,
"Curve Files (*.dat)")
if os.path.exists(file_name):
self._main_form.program_settings.setValue(
"DataDir", os.path.dirname(file_name))
self._main_form.program_settings.sync()
if file_name:
with open(file_name, "r") as open_file:
lines = open_file.readlines()
if len(lines) > 1:
a = lines[1].split()
self.txtDescription.setText(a[len(a) - 1])
if len(lines) > 2:
curve_xy = []
for i in range(2, len(lines)):
try:
x, y = lines[i].split()
xval, xval_is_good = ParseData.floatTryParse(x)
yval, yval_is_good = ParseData.floatTryParse(y)
if xval_is_good and yval_is_good:
curve_xy.append((x, y))
point_count = -1
for point in curve_xy:
point_count += 1
led = QLineEdit(str(point[0]))
self.tblMult.setItem(point_count, 0,
QTableWidgetItem(led.text()))
led = QLineEdit(str(point[1]))
self.tblMult.setItem(point_count, 1,
QTableWidgetItem(led.text()))
pass
except Exception as ex:
pass
def tbl_2_changed(self, row, col):
if not self.loaded: return
if self.tbl_2.verticalHeaderItem(row) is None: return
item = self.tbl_2.item(row, col)
if item is None: return
key = self.tbl_2.verticalHeaderItem(row).text()
if "infiltration model" in key.lower():
self.defaults.properties_sub_values[key] = item.currentText()
else:
val, val_is_good = ParseData.floatTryParse(item.text())
if val_is_good:
self.defaults.properties_sub_values[key] = val
self.property_sub_changed = True
pass
def tblGeneric_changed(self, row, col):
if not self.loaded: return
if self.tblGeneric.verticalHeaderItem(row) is None: return
item = self.tblGeneric.item(row, col)
if item is None: return
key = self.tblGeneric.verticalHeaderItem(row).text()
if key == self.defaults.id_increment_key:
val, val_is_good = ParseData.intTryParse(item.text())
if val_is_good:
self.defaults.id_increment = val
else:
self.defaults.model_object_prefix[key] = item.text()
self.label_changed = True
pass
def cmdOK_Clicked(self):
section = self._main_form.project.options.dates
orig_start_date = section.start_date
orig_start_time = section.start_time
orig_report_start_date = section.report_start_date
orig_report_start_time = section.report_start_time
orig_end_date = section.end_date
orig_end_time = section.end_time
orig_sweep_end = section.sweep_end
orig_sweep_start = section.sweep_start
orig_dry_days = section.dry_days
section.start_date = self.dedStart.date().toString(section.DATE_FORMAT)
section.start_time = self.tmeStart.time().toString(section.TIME_FORMAT)
section.report_start_date = self.dedStartReport.date().toString(
section.DATE_FORMAT)
section.report_start_time = self.tmeReport.time().toString(
section.TIME_FORMAT)
section.end_date = self.dedEnd.date().toString(section.DATE_FORMAT)
section.end_time = self.tmeEnd.time().toString(section.TIME_FORMAT)
section.sweep_end = self.dedSweepEnd.date().toString(
section.DATE_SWEEP_FORMAT)
section.sweep_start = self.dedSweepStart.date().toString(
section.DATE_SWEEP_FORMAT)
val, val_is_good = ParseData.floatTryParse(self.txtAntecedent.text())
if val_is_good and val >= 0:
section.dry_days = val
if orig_start_date != section.start_date or \
orig_start_time != section.start_time or \
orig_report_start_date != section.report_start_date or \
orig_report_start_time != section.report_start_time or \
orig_end_date != section.end_date or \
orig_end_time != section.end_time or \
orig_sweep_end != section.sweep_end or \
orig_sweep_start != section.sweep_start or \
orig_dry_days != section.dry_days:
self._main_form.mark_project_as_unsaved()
self._main_form.program_settings.setValue(
"Geometry/" + "frmDates_geometry", self.saveGeometry())
self._main_form.program_settings.setValue(
"Geometry/" + "frmDates_state", self.saveState())
self.close()
def cmdOK_Clicked(self):
section = self._main_form.project.options.dates
section.start_date = self.dedStart.date().toString(section.DATE_FORMAT)
section.start_time = self.tmeStart.time().toString(section.TIME_FORMAT)
section.report_start_date = self.dedStartReport.date().toString(
section.DATE_FORMAT)
section.report_start_time = self.tmeReport.time().toString(
section.TIME_FORMAT)
section.end_date = self.dedEnd.date().toString(section.DATE_FORMAT)
section.end_time = self.tmeEnd.time().toString(section.TIME_FORMAT)
section.sweep_end = self.dedSweepEnd.date().toString(
section.DATE_SWEEP_FORMAT)
section.sweep_start = self.dedSweepStart.date().toString(
section.DATE_SWEEP_FORMAT)
val, val_is_good = ParseData.floatTryParse(self.txtAntecedent.text())
if val_is_good and val >= 0:
section.dry_days = val
self.close()
def tbl_3_changed(self, row, col):
if not self.loaded: return
if self.tbl_3.verticalHeaderItem(row) is None: return
item = self.tbl_3.item(row, col)
if item is None: return
key = self.tbl_3.verticalHeaderItem(row).text()
if "flow units" in key.lower() or \
"link offsets" in key.lower() or \
"routing" in key.lower() or \
"force main" in key.lower():
# do nothing
pass
elif "conduit geometry" in key.lower():
#self.defaults.xsection.shape = CrossSection[item.text()]
pass
else:
val, val_is_good = ParseData.floatTryParse(item.text())
if val_is_good:
self.defaults.parameters_values[key] = val
self.parameter_changed = True
pass
def table_itemChanged(self, item):
if self.tblGeneric.currentItem() is None: return
new_val, new_val_is_good = ParseData.floatTryParse(self.tblGeneric.currentItem().text())
if not new_val_is_good: return
vtitle = self.tblGeneric.verticalHeaderItem(self.tblGeneric.currentRow()).text()
attr_name = ""
for i in range(0, len(self.meta)):
if self.meta[i].label == vtitle:
attr_name = self.meta[i].attribute
break
if len(attr_name) == 0: return
enum_val = E_InfilModel[self.cboInfilModel.currentText().upper()]
if enum_val == E_InfilModel.MODIFIED_HORTON:
self.defaults.infil_model_horton.__dict__[attr_name] = new_val
elif enum_val == E_InfilModel.MODIFIED_GREEN_AMPT:
self.defaults.infil_model_ga.__dict__[attr_name] = new_val
elif enum_val == E_InfilModel.CURVE_NUMBER:
self.defaults.infil_model_cn.__dict__[attr_name] = new_val
pass
def set_from(self, project):
section = project.options.time_steps
self.cbxSkip.setChecked(section.skip_steady_state)
self.sbxLateral.setValue(int(section.lateral_inflow_tolerance))
self.sbxSystem.setValue(int(section.system_flow_tolerance))
(days, hours, minutes,
seconds) = frmTimeSteps.split_days(section.dry_step)
self.sbxDry.setValue(days)
self.tmeDry.setTime(QtCore.QTime(hours, minutes, seconds))
(days, hours, minutes,
seconds) = frmTimeSteps.split_days(section.wet_step)
self.sbxWet.setValue(days)
self.tmeWet.setTime(QtCore.QTime(hours, minutes, seconds))
(days, hours, minutes,
seconds) = frmTimeSteps.split_days(section.report_step)
self.sbxReportDay.setValue(days)
self.tmeReport.setTime(QtCore.QTime(hours, minutes, seconds))
(days, hours, minutes,
seconds) = frmTimeSteps.split_days(section.rule_step)
self.tmeControl.setTime(QtCore.QTime(hours, minutes, seconds))
if ':' in section.routing_step:
if len(section.routing_step.split(':')
[0]) == 1: # Delphi GUI writes routing step as h:mm:ss
routing_time = QtCore.QTime(0, 0, 0).secsTo(
QtCore.QTime.fromString(section.routing_step, 'h:mm:ss'))
else:
routing_time = QtCore.QTime(0, 0, 0).secsTo(
QtCore.QTime.fromString(section.routing_step,
section.TIME_FORMAT))
else:
routing_time, good_int = ParseData.get_int_from_float(
section.routing_step)
self.txtRouting.setText(str(routing_time))
def set_all(self, project):
evap_section = project.evaporation
# "Constant Value","Time Series","Climate File","Monthly Averages","Temperatures"
self.evap_pan_list = evap_section.monthly_pan_coefficients
self.evap_monthly_list = evap_section.monthly
if evap_section.format == EvaporationFormat.UNSET:
self.cboEvap.setCurrentIndex(0)
self.cboEvap_currentIndexChanged(0)
elif evap_section.format == EvaporationFormat.CONSTANT:
self.cboEvap.setCurrentIndex(0)
self.cboEvap_currentIndexChanged(0)
elif evap_section.format == EvaporationFormat.MONTHLY:
self.cboEvap.setCurrentIndex(3)
self.cboEvap_currentIndexChanged(3)
elif evap_section.format == EvaporationFormat.TIMESERIES:
self.cboEvap.setCurrentIndex(1)
self.cboEvap_currentIndexChanged(1)
elif evap_section.format == EvaporationFormat.TEMPERATURE:
self.cboEvap.setCurrentIndex(4)
self.cboEvap_currentIndexChanged(4)
elif evap_section.format == EvaporationFormat.FILE:
self.cboEvap.setCurrentIndex(2)
self.cboEvap_currentIndexChanged(2)
if evap_section.constant == '':
evap_section.constant = 0.0
self.txtDaily.setText(str(evap_section.constant))
self.cbxDry.setChecked(evap_section.dry_only)
time_series_section = project.find_section("TIMESERIES")
time_series_list = time_series_section.value[0:]
self.cboEvapTs.clear()
selected_index = 0
for value in time_series_list:
self.cboEvapTs.addItem(value.name)
if value.name == evap_section.timeseries:
selected_index = int(self.cboEvapTs.count()) - 1
self.cboEvapTs.setCurrentIndex(selected_index)
pattern_section = project.find_section("PATTERNS")
pattern_list = pattern_section.value[0:]
self.cboMonthly.clear()
self.cboMonthly.addItem("")
selected_index = 0
previous_pattern = ""
for value in pattern_list:
if value.name and value.name != previous_pattern:
self.cboMonthly.addItem(value.name)
previous_pattern = value.name
if value.name == evap_section.recovery_pattern:
selected_index = int(self.cboMonthly.count()) - 1
self.cboMonthly.setCurrentIndex(selected_index)
temp_section = project.temperature
if temp_section.source == TemperatureSource.UNSET:
self.rbnTimeseries.setChecked(False)
self.rbnExternal.setChecked(False)
self.rbnNoData.setChecked(True)
elif temp_section.source == TemperatureSource.TIMESERIES and temp_section.timeseries:
self.rbnTimeseries.setChecked(True)
self.rbnExternal.setChecked(False)
self.rbnNoData.setChecked(False)
elif temp_section.source == TemperatureSource.FILE:
self.rbnTimeseries.setChecked(False)
self.rbnExternal.setChecked(True)
self.rbnNoData.setChecked(False)
else:
self.rbnTimeseries.setChecked(False)
self.rbnExternal.setChecked(False)
self.rbnNoData.setChecked(True)
time_series_section = project.timeseries
time_series_list = time_series_section.value[0:]
self.cboTimeSeries.clear()
self.cboTimeSeries.addItem('')
selected_index = 0
for value in time_series_list:
self.cboTimeSeries.addItem(value.name)
if value.name == temp_section.timeseries:
selected_index = self.cboTimeSeries.count()
self.cboTimeSeries.setCurrentIndex(selected_index)
self.txtClimate.setText(temp_section.filename)
self.dedStart.setDate(
QtCore.QDate.fromString(temp_section.start_date, "MM/dd/yyyy"))
if temp_section.start_date:
self.cbxStart.setChecked(True)
# wind speed tab
if temp_section.wind_speed.source == WindSource.MONTHLY:
self.rbnMonthly.setChecked(True)
monthly_list = temp_section.wind_speed.wind_speed_monthly
point_count = -1
for value in monthly_list:
point_count += 1
led = QtGui.QLineEdit(str(value))
self.tblWind.setItem(0, point_count,
QtGui.QTableWidgetItem(led.text()))
elif temp_section.wind_speed.source == WindSource.FILE:
self.rbnUseClimate.setChecked(True)
# snow melt tab
val, val_is_good = ParseData.floatTryParse(
temp_section.snow_melt.snow_temp)
if not val_is_good:
val = 34
self.txtSnowDivide.setText(str(val))
self.txtSnowATI.setText(str(temp_section.snow_melt.ati_weight))
self.txtSnowMelt.setText(
str(temp_section.snow_melt.negative_melt_ratio))
self.txtSnowElevation.setText(str(temp_section.snow_melt.elevation))
val, val_is_good = ParseData.floatTryParse(
temp_section.snow_melt.latitude)
if not val_is_good or val == 0.0:
val = 50.0
self.txtSnowLatitude.setText(str(val))
self.txtSnowLongitude.setText(
str(temp_section.snow_melt.time_correction))
# areal depletion
areal_list = temp_section.areal_depletion.adc_impervious
if len(areal_list) > 0:
point_count = -1
for value in areal_list:
point_count += 1
led = QtGui.QLineEdit(str(value))
self.tblAreal.setItem(point_count, 0,
QtGui.QTableWidgetItem(led.text()))
else:
self.btnImpNo_Clicked()
areal_list = temp_section.areal_depletion.adc_pervious
if len(areal_list) > 0:
point_count = -1
for value in areal_list:
point_count += 1
led = QtGui.QLineEdit(str(value))
self.tblAreal.setItem(point_count, 1,
QtGui.QTableWidgetItem(led.text()))
pass
else:
self.btnPerNo_Clicked()
# self.tblAreal.resizeColumnsToContents()
# adjustments for temp, evap, rain, cond
adjustments_section = project.find_section("ADJUSTMENTS")
temp_list = adjustments_section.temperature
point_count = -1
for value in temp_list:
point_count += 1
led = QtGui.QLineEdit(str(value))
self.tblAdjustments.setItem(point_count, 0,
QtGui.QTableWidgetItem(led.text()))
evap_list = adjustments_section.evaporation
point_count = -1
for value in evap_list:
point_count += 1
led = QtGui.QLineEdit(str(value))
self.tblAdjustments.setItem(point_count, 1,
QtGui.QTableWidgetItem(led.text()))
rain_list = adjustments_section.rainfall
point_count = -1
for value in rain_list:
point_count += 1
led = QtGui.QLineEdit(str(value))
self.tblAdjustments.setItem(point_count, 2,
QtGui.QTableWidgetItem(led.text()))
cond_list = adjustments_section.soil_conductivity
point_count = -1
for value in cond_list:
point_count += 1
led = QtGui.QLineEdit(str(value))
self.tblAdjustments.setItem(point_count, 3,
QtGui.QTableWidgetItem(led.text()))
def set_link(self, project, link_name):
# assume we want to edit the first one
self.link_name = link_name
value = None
try:
value = self._main_form.project.xsections.get_item(
"link", self.link_name)
except: # This must be a new one we need to add
value = None
if not value:
value = core.swmm.hydraulics.link.CrossSection()
value.link = self.link_name
if self._main_form and self._main_form.project_settings:
self._main_form.project_settings.apply_default_attributes(
value)
self._main_form.project.xsections.value.append(value)
for value in project.xsections.value:
if value.link == link_name:
# this is the link we want to edit
for list_index in range(0, self.listWidget.count()):
list_item = self.listWidget.item(list_index)
if str(list_item.text()).upper() == value.shape.name:
self.listWidget.setCurrentItem(list_item)
elif str(list_item.text(
)) == 'Force Main' and value.shape.name == 'FORCE_MAIN':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Filled Circular' and value.shape.name == 'FILLED_CIRCULAR':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Closed Rectangular' and value.shape.name == 'RECT_CLOSED':
self.listWidget.setCurrentItem(list_item)
elif str(list_item.text(
)) == 'Rectangular' and value.shape.name == 'RECT_OPEN':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Horizontal Elliptical' and value.shape.name == 'HORIZ_ELLIPSE':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Vertical Elliptical' and value.shape.name == 'VERT_ELLIPSE':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Rectangular Triangular' and value.shape.name == 'RECT_TRIANGULAR':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Rectangular Round' and value.shape.name == 'RECT_ROUND':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Modified Baskethandle' and value.shape.name == 'MODBASKETHANDLE':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Semi-Elliptical' and value.shape.name == 'SEMIELLIPTICAL':
self.listWidget.setCurrentItem(list_item)
elif str(
list_item.text()
) == 'Semi-Circular' and value.shape.name == 'SEMICIRCULAR':
self.listWidget.setCurrentItem(list_item)
ibarrels, good_int = ParseData.get_int_from_float(
value.barrels)
if good_int:
self.sbxNumber.setValue(ibarrels)
self.txt1.setText(str(value.geometry1))
self.txt2.setText(str(value.geometry2))
self.txt3.setText(str(value.geometry3))
self.txt4.setText(str(value.geometry4))
# for rect_open sidewalls, set geom3 to 0,1,2 for None, One, Both
if value.shape.name == 'RECTANGULAR':
self.cboCombo.setCurrentIndex(int(value.geometry3))
# for horizontal and vertical elliptical and arch, combo gets standard sizes
if value.shape.name == 'HORIZ_ELLIPSE':
self.cboCombo.setCurrentIndex(int(value.geometry3))
if value.shape.name == 'VERT_ELLIPSE':
self.cboCombo.setCurrentIndex(int(value.geometry3))
if value.shape.name == 'ARCH':
self.cboCombo.setCurrentIndex(int(value.geometry3))
if value.shape.name == 'IRREGULAR':
# for irregular, combo needs transect names, dialog opens transect buttons
for index in range(0, self.cboCombo.count()):
if value.geometry1 == self.cboCombo.itemText(index):
self.cboCombo.setCurrentIndex(index)
if value.shape.name == 'CUSTOM':
# for custom, combo needs shape curves, dialog opens shape curve editor
for index in range(0, self.cboCombo.count()):
if value.curve == self.cboCombo.itemText(index):
self.cboCombo.setCurrentIndex(index)
def check_coords(self):
# check source LL coordinates
new_src_LL = Coordinate()
val, val_is_good = ParseData.floatTryParse(self.ui.txtLL_src_x.text())
if val_is_good:
new_src_LL.x = val
else:
return False
val, val_is_good = ParseData.floatTryParse(self.ui.txtLL_src_y.text())
if val_is_good:
new_src_LL.y = val
else:
return False
# check source UR coordinates
new_src_UR = Coordinate()
val, val_is_good = ParseData.floatTryParse(self.ui.txtUR_src_x.text())
if val_is_good:
new_src_UR.x = val
else:
return False
val, val_is_good = ParseData.floatTryParse(self.ui.txtUR_src_y.text())
if val_is_good:
new_src_UR.y = val
else:
return False
# check destination LL coordinates
new_dst_LL = Coordinate()
val, val_is_good = ParseData.floatTryParse(self.ui.txtLL_dst_x.text())
if val_is_good:
new_dst_LL.x = val
else:
return False
val, val_is_good = ParseData.floatTryParse(self.ui.txtLL_dst_y.text())
if val_is_good:
new_dst_LL.y = val
else:
return False
# check destination UR coordinates
new_dst_UR = Coordinate()
val, val_is_good = ParseData.floatTryParse(self.ui.txtUR_dst_x.text())
if val_is_good:
new_dst_UR.x = val
else:
return False
val, val_is_good = ParseData.floatTryParse(self.ui.txtUR_dst_y.text())
if val_is_good:
new_dst_UR.y = val
else:
return False
self.pt_src_ll.x = new_src_LL.x
self.pt_src_ll.y = new_src_LL.y
self.pt_src_ur.x = new_src_UR.x
self.pt_src_ur.y = new_src_UR.y
if not self.pt_dst_ll:
self.pt_dst_ll = type(self.pt_src_ll)()
if not self.pt_dst_ur:
self.pt_dst_ur = type(self.pt_src_ur)()
self.pt_dst_ll.x = new_dst_LL.x
self.pt_dst_ll.y = new_dst_LL.y
self.pt_dst_ur.x = new_dst_UR.x
self.pt_dst_ur.y = new_dst_UR.y
return True
