void HornOfValere::FindHorn(CvUnit* pUnit)
{
// TODO UI popup
if (pUnit)
{
m_bFound = true;
CvPlot* pkPlot = GetPlot();
if (pkPlot)
{
pkPlot->SetHasHornOfValere(false);
}
m_iOwnerPlayerID = pUnit->getOwner();
m_iOwnerUnitID = pUnit->GetID();
ICvEngineScriptSystem1* pkScriptSystem = gDLL->GetScriptSystem();
if (pkScriptSystem)
{
CUSTOMLOG("Calling UnitDiscoveredHornOfValere with %i owner and %i unit ID.", pUnit->getOwner(), pUnit->GetID());
CvLuaArgsHandle args;
args->Push(pUnit->getOwner());
args->Push(pUnit->GetID());
bool bResult;
LuaSupport::CallHook(pkScriptSystem, "UnitDiscoveredHornOfValere", args.get(), bResult);
}
}
}
GarrisonError Garrison::CheckBuildingPlacement(uint32 garrPlotInstanceId, uint32 garrBuildingId) const
{
GarrPlotInstanceEntry const* plotInstance = sGarrPlotInstanceStore.LookupEntry(garrPlotInstanceId);
Plot const* plot = GetPlot(garrPlotInstanceId);
if (!plotInstance || !plot)
return GARRISON_ERROR_INVALID_PLOT_INSTANCEID;
GarrBuildingEntry const* building = sGarrBuildingStore.LookupEntry(garrBuildingId);
if (!building)
return GARRISON_ERROR_INVALID_BUILDINGID;
if (!sGarrisonMgr.IsPlotMatchingBuilding(plotInstance->GarrPlotID, garrBuildingId))
return GARRISON_ERROR_INVALID_PLOT_BUILDING;
// Cannot place buldings of higher level than garrison level
if (building->Level > _siteLevel->Level)
return GARRISON_ERROR_INVALID_BUILDINGID;
if (building->Flags & GARRISON_BUILDING_FLAG_NEEDS_PLAN)
{
if (!_knownBuildings.count(garrBuildingId))
return GARRISON_ERROR_REQUIRES_BLUEPRINT;
}
else // Building is built as a quest reward
return GARRISON_ERROR_INVALID_BUILDINGID;
// Check all plots to find if we already have this building
GarrBuildingEntry const* existingBuilding;
for (auto const& p : _plots)
{
if (p.second.BuildingInfo.PacketInfo)
{
existingBuilding = sGarrBuildingStore.AssertEntry(p.second.BuildingInfo.PacketInfo->GarrBuildingID);
if (existingBuilding->Type == building->Type)
if (p.first != garrPlotInstanceId || existingBuilding->Level + 1 != building->Level) // check if its an upgrade in same plot
return GARRISON_ERROR_BUILDING_EXISTS;
}
}
if (!_owner->HasCurrency(building->CostCurrencyID, building->CostCurrencyAmount))
return GARRISON_ERROR_NOT_ENOUGH_CURRENCY;
if (!_owner->HasEnoughMoney(uint64(building->CostMoney) * GOLD))
return GARRISON_ERROR_NOT_ENOUGH_GOLD;
// New building cannot replace another building currently under construction
if (plot->BuildingInfo.PacketInfo)
if (!plot->BuildingInfo.PacketInfo->Active)
return GARRISON_ERROR_NO_BUILDING;
return GARRISON_SUCCESS;
}
void HornOfValere::MoveHorn(CvPlot* pkNewPlot)
{
CvPlot* pkPlot = GetPlot();
if (pkPlot)
{
pkPlot->SetHasHornOfValere(false);
}
m_iXPosition = pkNewPlot->getX();
m_iYPosition = pkNewPlot->getY();
pkNewPlot->SetHasHornOfValere(true);
}
GarrisonError Garrison::CheckBuildingRemoval(uint32 garrPlotInstanceId) const
{
Plot const* plot = GetPlot(garrPlotInstanceId);
if (!plot)
return GARRISON_ERROR_INVALID_PLOT_INSTANCEID;
if (!plot->BuildingInfo.PacketInfo)
return GARRISON_ERROR_NO_BUILDING;
if (plot->BuildingInfo.CanActivate())
return GARRISON_ERROR_BUILDING_EXISTS;
return GARRISON_SUCCESS;
}
void Garrison::CancelBuildingConstruction(uint32 garrPlotInstanceId)
{
WorldPackets::Garrison::GarrisonBuildingRemoved buildingRemoved;
buildingRemoved.GarrTypeID = GARRISON_TYPE_GARRISON;
buildingRemoved.Result = CheckBuildingRemoval(garrPlotInstanceId);
if (buildingRemoved.Result == GARRISON_SUCCESS)
{
Plot* plot = GetPlot(garrPlotInstanceId);
buildingRemoved.GarrPlotInstanceID = garrPlotInstanceId;
buildingRemoved.GarrBuildingID = plot->BuildingInfo.PacketInfo->GarrBuildingID;
Map* map = FindMap();
if (map)
plot->DeleteGameObject(map);
plot->ClearBuildingInfo(_owner);
_owner->SendDirectMessage(buildingRemoved.Write());
GarrBuildingEntry const* constructing = sGarrBuildingStore.AssertEntry(buildingRemoved.GarrBuildingID);
// Refund construction/upgrade cost
_owner->ModifyCurrency(constructing->CostCurrencyID, constructing->CostCurrencyAmount, false, true);
_owner->ModifyMoney(constructing->CostMoney * GOLD, false);
if (constructing->Level > 1)
{
// Restore previous level building
uint32 restored = sGarrisonMgr.GetPreviousLevelBuildingId(constructing->Type, constructing->Level);
ASSERT(restored);
WorldPackets::Garrison::GarrisonPlaceBuildingResult placeBuildingResult;
placeBuildingResult.GarrTypeID = GARRISON_TYPE_GARRISON;
placeBuildingResult.Result = GARRISON_SUCCESS;
placeBuildingResult.BuildingInfo.GarrPlotInstanceID = garrPlotInstanceId;
placeBuildingResult.BuildingInfo.GarrBuildingID = restored;
placeBuildingResult.BuildingInfo.TimeBuilt = time(nullptr);
placeBuildingResult.BuildingInfo.Active = true;
plot->SetBuildingInfo(placeBuildingResult.BuildingInfo, _owner);
_owner->SendDirectMessage(placeBuildingResult.Write());
}
if (map)
if (GameObject* go = plot->CreateGameObject(map, GetFaction()))
map->AddToMap(go);
}
else
_owner->SendDirectMessage(buildingRemoved.Write());
}
void Garrison::PlaceBuilding(uint32 garrPlotInstanceId, uint32 garrBuildingId)
{
WorldPackets::Garrison::GarrisonPlaceBuildingResult placeBuildingResult;
placeBuildingResult.GarrTypeID = GARRISON_TYPE_GARRISON;
placeBuildingResult.Result = CheckBuildingPlacement(garrPlotInstanceId, garrBuildingId);
if (placeBuildingResult.Result == GARRISON_SUCCESS)
{
placeBuildingResult.BuildingInfo.GarrPlotInstanceID = garrPlotInstanceId;
placeBuildingResult.BuildingInfo.GarrBuildingID = garrBuildingId;
placeBuildingResult.BuildingInfo.TimeBuilt = time(nullptr);
Plot* plot = GetPlot(garrPlotInstanceId);
uint32 oldBuildingId = 0;
Map* map = FindMap();
GarrBuildingEntry const* building = sGarrBuildingStore.AssertEntry(garrBuildingId);
if (map)
plot->DeleteGameObject(map);
if (plot->BuildingInfo.PacketInfo)
{
oldBuildingId = plot->BuildingInfo.PacketInfo->GarrBuildingID;
if (sGarrBuildingStore.AssertEntry(oldBuildingId)->Type != building->Type)
plot->ClearBuildingInfo(_owner);
}
plot->SetBuildingInfo(placeBuildingResult.BuildingInfo, _owner);
if (map)
if (GameObject* go = plot->CreateGameObject(map, GetFaction()))
map->AddToMap(go);
_owner->ModifyCurrency(building->CostCurrencyID, -building->CostCurrencyAmount, false, true);
_owner->ModifyMoney(-building->CostMoney * GOLD, false);
if (oldBuildingId)
{
WorldPackets::Garrison::GarrisonBuildingRemoved buildingRemoved;
buildingRemoved.GarrTypeID = GARRISON_TYPE_GARRISON;
buildingRemoved.Result = GARRISON_SUCCESS;
buildingRemoved.GarrPlotInstanceID = garrPlotInstanceId;
buildingRemoved.GarrBuildingID = oldBuildingId;
_owner->SendDirectMessage(buildingRemoved.Write());
}
_owner->UpdateCriteria(CRITERIA_TYPE_PLACE_GARRISON_BUILDING, garrBuildingId);
}
_owner->SendDirectMessage(placeBuildingResult.Write());
}
//______________________________________________________________________________
void TFractionFitter::ComputeChisquareLambda()
{
// Method used internally to compute the likelihood ratio chi2
// See the function GetChisquare() for details
if ( !fFitDone ) {
Error("ComputeChisquareLambda","Fit not yet (successfully) performed");
fChisquare = 0;
return;
}
// fPlot must be initialized and filled. Leave this to the GetPlot() method.
if (! fPlot)
GetPlot();
Int_t minX, maxX, minY, maxY, minZ, maxZ;
GetRanges(minX, maxX, minY, maxY, minZ, maxZ);
Double_t logLyn = 0; // likelihood of prediction
Double_t logLmn = 0; // likelihood of data ("true" distribution)
for(Int_t x = minX; x <= maxX; x++) {
for(Int_t y = minY; y <= maxY; y++) {
for(Int_t z = minZ; z <= maxZ; z++) {
if (IsExcluded(fData->GetBin(x, y, z))) continue;
Double_t di = fData->GetBinContent(x, y, z);
Double_t fi = fPlot->GetBinContent(x, y, z);
if(fi != 0) logLyn += di * TMath::Log(fi) - fi;
if(di != 0) logLmn += di * TMath::Log(di) - di;
for(Int_t j = 0; j < fNpar; j++) {
Double_t aji = ((TH1*)fMCs.At(j))->GetBinContent(x, y, z);
Double_t bji = ((TH1*)fAji.At(j))->GetBinContent(x, y, z);
if(bji != 0) logLyn += aji * TMath::Log(bji) - bji;
if(aji != 0) logLmn += aji * TMath::Log(aji) - aji;
}
}
}
}
fChisquare = -2*logLyn + 2*logLmn;
return;
}
void Garrison::ActivateBuilding(uint32 garrPlotInstanceId)
{
if (Plot* plot = GetPlot(garrPlotInstanceId))
{
if (plot->BuildingInfo.CanActivate() && plot->BuildingInfo.PacketInfo && !plot->BuildingInfo.PacketInfo->Active)
{
plot->BuildingInfo.PacketInfo->Active = true;
if (Map* map = FindMap())
{
plot->DeleteGameObject(map);
if (GameObject* go = plot->CreateGameObject(map, GetFaction()))
map->AddToMap(go);
}
WorldPackets::Garrison::GarrisonBuildingActivated buildingActivated;
buildingActivated.GarrPlotInstanceID = garrPlotInstanceId;
_owner->SendDirectMessage(buildingActivated.Write());
}
}
}
void VideoMetadata::toMap(MetadataMap &metadataMap)
{
if (this == NULL)
return;
QString coverfile;
if (IsHostSet()
&& !GetCoverFile().startsWith("/")
&& !GetCoverFile().isEmpty()
&& !IsDefaultCoverFile(GetCoverFile()))
{
coverfile = generate_file_url("Coverart", GetHost(),
GetCoverFile());
}
else
{
coverfile = GetCoverFile();
}
metadataMap["coverfile"] = coverfile;
QString screenshotfile;
if (IsHostSet() && !GetScreenshot().startsWith("/")
&& !GetScreenshot().isEmpty())
{
screenshotfile = generate_file_url("Screenshots",
GetHost(), GetScreenshot());
}
else
{
screenshotfile = GetScreenshot();
}
metadataMap["screenshotfile"] = screenshotfile;
QString bannerfile;
if (IsHostSet() && !GetBanner().startsWith("/")
&& !GetBanner().isEmpty())
{
bannerfile = generate_file_url("Banners", GetHost(),
GetBanner());
}
else
{
bannerfile = GetBanner();
}
metadataMap["bannerfile"] = bannerfile;
QString fanartfile;
if (IsHostSet() && !GetFanart().startsWith("/")
&& !GetFanart().isEmpty())
{
fanartfile = generate_file_url("Fanart", GetHost(),
GetFanart());
}
else
{
fanartfile = GetFanart();
}
metadataMap["fanartfile"] = fanartfile;
metadataMap["filename"] = GetFilename();
metadataMap["title"] = GetTitle();
metadataMap["subtitle"] = GetSubtitle();
metadataMap["tagline"] = GetTagline();
metadataMap["director"] = GetDirector();
metadataMap["studio"] = GetStudio();
metadataMap["description"] = GetPlot();
metadataMap["genres"] = GetDisplayGenres(*this);
metadataMap["countries"] = GetDisplayCountries(*this);
metadataMap["cast"] = GetDisplayCast(*this).join(", ");
metadataMap["rating"] = GetDisplayRating(GetRating());
metadataMap["length"] = GetDisplayLength(GetLength());
metadataMap["year"] = GetDisplayYear(GetYear());
metadataMap["releasedate"] = MythDateToString(GetReleaseDate(), kDateFull);
metadataMap["userrating"] = GetDisplayUserRating(GetUserRating());
metadataMap["season"] = GetDisplaySeasonEpisode(GetSeason(), 1);
metadataMap["episode"] = GetDisplaySeasonEpisode(GetEpisode(), 1);
if (GetSeason() > 0 || GetEpisode() > 0)
{
metadataMap["s##e##"] = QString("s%1e%2").arg(GetDisplaySeasonEpisode
(GetSeason(), 2))
.arg(GetDisplaySeasonEpisode(GetEpisode(), 2));
metadataMap["##x##"] = QString("%1x%2").arg(GetDisplaySeasonEpisode
(GetSeason(), 1))
.arg(GetDisplaySeasonEpisode(GetEpisode(), 2));
}
else
metadataMap["s##e##"] = metadataMap["##x##"] = QString();
metadataMap["trailerstate"] = TrailerToState(GetTrailer());
metadataMap["userratingstate"] =
QString::number((int)(GetUserRating()));
metadataMap["watchedstate"] = WatchedToState(GetWatched());
metadataMap["videolevel"] = ParentalLevelToState(GetShowLevel());
metadataMap["insertdate"] = MythDateToString(GetInsertdate(), kDateFull);
metadataMap["inetref"] = GetInetRef();
metadataMap["homepage"] = GetHomepage();
metadataMap["child_id"] = QString::number(GetChildID());
metadataMap["browseable"] = GetDisplayBrowse(GetBrowse());
metadataMap["watched"] = GetDisplayWatched(GetWatched());
metadataMap["processed"] = GetDisplayProcessed(GetProcessed());
metadataMap["category"] = GetCategory();
}
bool Garrison::LoadFromDB(PreparedQueryResult garrison, PreparedQueryResult blueprints, PreparedQueryResult buildings,
PreparedQueryResult followers, PreparedQueryResult abilities)
{
if (!garrison)
return false;
Field* fields = garrison->Fetch();
_siteLevel = sGarrSiteLevelStore.LookupEntry(fields[0].GetUInt32());
_followerActivationsRemainingToday = fields[1].GetUInt32();
if (!_siteLevel)
return false;
InitializePlots();
if (blueprints)
{
do
{
fields = blueprints->Fetch();
if (GarrBuildingEntry const* building = sGarrBuildingStore.LookupEntry(fields[0].GetUInt32()))
_knownBuildings.insert(building->ID);
} while (blueprints->NextRow());
}
if (buildings)
{
do
{
fields = buildings->Fetch();
uint32 plotInstanceId = fields[0].GetUInt32();
uint32 buildingId = fields[1].GetUInt32();
time_t timeBuilt = time_t(fields[2].GetUInt64());
bool active = fields[3].GetBool();
Plot* plot = GetPlot(plotInstanceId);
if (!plot)
continue;
if (!sGarrBuildingStore.LookupEntry(buildingId))
continue;
plot->BuildingInfo.PacketInfo = boost::in_place();
plot->BuildingInfo.PacketInfo->GarrPlotInstanceID = plotInstanceId;
plot->BuildingInfo.PacketInfo->GarrBuildingID = buildingId;
plot->BuildingInfo.PacketInfo->TimeBuilt = timeBuilt;
plot->BuildingInfo.PacketInfo->Active = active;
} while (buildings->NextRow());
}
// 0 1 2 3 4 5 6 7 8 9
// SELECT dbId, followerId, quality, level, itemLevelWeapon, itemLevelArmor, xp, currentBuilding, currentMission, status FROM character_garrison_followers WHERE guid = ?
if (followers)
{
do
{
fields = followers->Fetch();
uint64 dbId = fields[0].GetUInt64();
uint32 followerId = fields[1].GetUInt32();
if (!sGarrFollowerStore.LookupEntry(followerId))
continue;
_followerIds.insert(followerId);
Follower& follower = _followers[dbId];
follower.PacketInfo.DbID = dbId;
follower.PacketInfo.GarrFollowerID = followerId;
follower.PacketInfo.Quality = fields[2].GetUInt32();
follower.PacketInfo.FollowerLevel = fields[3].GetUInt32();
follower.PacketInfo.ItemLevelWeapon = fields[4].GetUInt32();
follower.PacketInfo.ItemLevelArmor = fields[5].GetUInt32();
follower.PacketInfo.Xp = fields[6].GetUInt32();
follower.PacketInfo.CurrentBuildingID = fields[7].GetUInt32();
follower.PacketInfo.CurrentMissionID = fields[8].GetUInt32();
follower.PacketInfo.FollowerStatus = fields[9].GetUInt32();
if (!sGarrBuildingStore.LookupEntry(follower.PacketInfo.CurrentBuildingID))
follower.PacketInfo.CurrentBuildingID = 0;
//if (!sGarrMissionStore.LookupEntry(follower.PacketInfo.CurrentMissionID))
// follower.PacketInfo.CurrentMissionID = 0;
} while (followers->NextRow());
if (abilities)
{
do
{
fields = abilities->Fetch();
uint64 dbId = fields[0].GetUInt64();
GarrAbilityEntry const* ability = sGarrAbilityStore.LookupEntry(fields[1].GetUInt32());
if (!ability)
continue;
auto itr = _followers.find(dbId);
if (itr == _followers.end())
continue;
itr->second.PacketInfo.AbilityID.push_back(ability);
} while (abilities->NextRow());
}
}
return true;
}
void compIsol(int varnum)
{
TString varname, vartitle;
if(varnum==1) {
varname="hHEIsoPt";
vartitle="H/E Isolation";
}
if(varnum==2) {
varname="hHcalIsoPt";
vartitle="HCAL Isolation";
}
if(varnum==3) {
varname="hEcalIsoPt";
vartitle="ECAL Isolation";
}
if(varnum==4) {
varname="hTrkIsoPt";
vartitle="Track Isolation";
}
if(varnum==5) {
varname="hJetEt";
vartitle="Jet E_{T} [GeV]";
}
if(varnum==6) {
varname="hNJets";
vartitle="Number of Jets";
}
TH1D* hBorn;
TH1D* hADD;
if(varnum<=4) {
TH2D* hBorn2d = dynamic_cast<TH2D*>(GetPlot(1, varname));
TH2D* hADD2d = dynamic_cast<TH2D*>(GetPlot(3, varname));
hBorn = hBorn2d->ProjectionX(varname+"born");
hADD = hADD2d->ProjectionX(varname+"add");
cout << "asdf" << endl;
} else {
hBorn = dynamic_cast<TH1D*>(GetPlot(1, varname));
hADD = dynamic_cast<TH1D*>(GetPlot(3, varname));
}
hBorn->Scale(1/hBorn->GetSumOfWeights());
hADD->Scale(1/hADD->GetSumOfWeights());
hBorn->SetLineColor(kBlue+2);
hADD->SetLineColor(kCyan+4);
hBorn->SetFillColor(0);
hADD->SetFillColor(0);
hBorn->SetLineStyle(1);
hADD->SetLineStyle(2);
// hBorn->SetStats(0);
// hADD->SetStats(0);
gPad->SetLogy(1);
hBorn->GetXaxis()->SetTitle(vartitle);
hBorn->GetYaxis()->SetTitle("Normalized Units");
hBorn->SetTitle("Leading Photons in Pythia/Sherpa Samples");
hBorn->Draw();
hADD->Draw("sames");
hBorn->SetMaximum(1);
gPad->Update();
TPaveStats *st1=(TPaveStats*)hBorn->GetListOfFunctions()->FindObject("stats");
TPaveStats *st2=(TPaveStats*)hADD->GetListOfFunctions()->FindObject("stats");
st1->SetName("Born");
st2->SetName("ADD");
st1->SetOptStat(101100);
st2->SetOptStat(101100);
st1->SetX1NDC(.25);
st1->SetX2NDC(.55);
st1->SetY1NDC(.56);
st1->SetY2NDC(.80);
st2->SetX1NDC(.56);
st2->SetX2NDC(.86);
st2->SetY1NDC(.56);
st2->SetY2NDC(.80);
TLegend* leg=new TLegend(.25,.78,.55,.85);
leg->AddEntry(hBorn, "Pythia (Born)", "l");
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->SetTextSize(0.045);
leg->Draw();
TLegend* leg=new TLegend(.56,.78,.86,.85);
leg->AddEntry(hADD, "Sherpa (ADD)", "l");
leg->SetBorderSize(0);
leg->SetFillColor(0);
leg->SetTextSize(0.045);
leg->Draw();
gPad->Update();
return;
}
ribi::QtToolTestApproximatorXyzMainDialog::QtToolTestApproximatorXyzMainDialog(QWidget *parent) noexcept :
QtHideAndShowDialog(parent),
ui(new Ui::QtToolTestApproximatorXyzMainDialog),
m_approximator(),
m_data(CreateData())
{
#ifndef NDEBUG
Test();
#endif
ui->setupUi(this);
//Set up the plots and curves
GetPlot(0)->setTitle("Approximator, for z = 0.0");
GetPlot(1)->setTitle("Approximator, for z = 0.5");
GetPlot(2)->setTitle("Approximator, for z = 1.0");
for (auto i=0; i!=m_n_curves; ++i)
{
const auto plot = GetPlot(i);
plot->setAxisTitle(QwtPlot::xBottom,"X");
plot->setAxisTitle(QwtPlot::yLeft,"Y");
#ifdef _WIN32
plot->setCanvasBackground(QBrush(QColor(255,255,255)));
#else
plot->setCanvasBackground(QColor(255,255,255));
#endif
const auto curve_values = GetCurveValues(i);
assert(curve_values);
curve_values->setTitle("Points");
curve_values->attach(plot.get());
curve_values->setStyle(QwtPlotCurve::Dots);
curve_values->setPen(QPen(QColor(255,0,0),5));
const auto curve_approximation = GetCurveApproximation(i);
assert(curve_approximation);
curve_approximation->setTitle("Approximation");
curve_approximation->attach(plot.get());
curve_approximation->setStyle(QwtPlotCurve::Dots);
curve_approximation->setPen(QPen(QColor(0,0,255),3));
//Add grid
{
QwtPlotGrid * const grid = new QwtPlotGrid;
grid->setPen(QPen(QColor(128,128,128)));
grid->attach(plot.get());
}
//Add zoomer
{
new QwtPlotZoomer(plot->canvas());
}
//Add legend
{
QwtLegend * const legend = new QwtLegend;
legend->setFrameStyle(QFrame::Box|QFrame::Sunken);
plot->insertLegend(legend, QwtPlot::RightLegend);
}
plot->setAxisScale(
QwtPlot::xBottom,
static_cast<double>(ui->box_int_x->minimum()),
static_cast<double>(ui->box_int_x->maximum())
);
plot->setAxisScale(
QwtPlot::yLeft,
static_cast<double>(ui->box_double_y->minimum()),
static_cast<double>(ui->box_double_y->maximum())
);
//Add to dialog
assert(ui->verticalLayout->layout());
ui->verticalLayout->layout()->addWidget(plot.get());
}
//Add some nice testing values
ui->box_int_x->setValue(ui->box_int_x->minimum() / 2);
ui->box_double_y->setValue(ui->box_double_y->maximum() / 2.0);
on_button_clicked();
ui->box_int_x->setValue(ui->box_int_x->minimum() / 4);
ui->box_double_y->setValue(ui->box_double_y->minimum() / 2.0);
on_button_clicked();
ui->box_int_x->setValue(ui->box_int_x->maximum() / 4);
ui->box_double_y->setValue(ui->box_double_y->maximum() / 2.0);
on_button_clicked();
ui->box_int_x->setValue(ui->box_int_x->maximum() / 2);
ui->box_double_y->setValue(ui->box_double_y->minimum() / 2.0);
on_button_clicked();
ui->box_int_x->setValue(0);
ui->box_double_y->setValue(0.0);
}
