Fr0zka/VoxelForge
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

audit: interior-air gate and gap-true ripple fitter on the cave planner (L147, audit only)

Browse Source 
Tunnel Network and Vertical Shafts 16-seed sweeps: 5,171,796 passage-interior capsule samples each, 0 solid;
no-passage controls fire 48/48; masked-gap ripple controls 48/48. Only seed 2 fails (known interface 2-3 shell
wall_missing, outside the interior). Owner hashes/plan/layout identical to HEAD.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016dhxM43dnWvUu2B5Ph1iG1
This commit is contained in:
Fr0zkaandClaude Opus 5.5 committed 2026-11-01 13:29:58 +01:00
1 parent 4f93f3fffb
commit a0d7ab3a1a
4 files changed
+393 -25
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Standalone/Source/StreamBenchmarkPipeline.h
+114 -25
View File
@@ -3036,6 +3036,7 @@ namespace StandaloneStreamBenchmark
struct FWalkAudit
{
std::uint64_t segments=0,centers=0,capsuleSamples=0,blocked=0;
std::uint64_t passageInteriorCapsuleSamples=0,passageInteriorSolidSamples=0;
std::uint64_t supportSamples=0,unsupported=0,gradeFailures=0;
std::uint64_t supportOverlapSkips=0;
std::array<std::array<double,4>,8> firstBlocked{};
@@ -3049,7 +3050,8 @@ namespace StandaloneStreamBenchmark
double supportStartMetres,double supportStepMetres,
double supportMaximumMetres,std::uint32_t minimumSupportProbes,
double supportProbeRadiusMetres,
const std::function<bool(double,double,double)>& supportExemption={})
const std::function<bool(double,double,double)>& supportExemption={},
const std::function<bool(double,double,double)>& passageInteriorPredicate={})
{
FWalkAudit audit;
if(path.size()<2)return audit;
@@ -3062,10 +3064,14 @@ namespace StandaloneStreamBenchmark
const auto solidAt=[&](double xMetres,double yMetres,double zMetres)
{
++audit.capsuleSamples;
const bool inPassageInterior=passageInteriorPredicate
&&passageInteriorPredicate(xMetres,yMetres,zMetres);
if(inPassageInterior)++audit.passageInteriorCapsuleSamples;
const VoxelForgeCore::Vec3d position{xMetres/coreMetres,yMetres/coreMetres,zMetres/coreMetres};
const float density=Field.densityAt(position);
if(density<0.0f)
{
if(inPassageInterior)++audit.passageInteriorSolidSamples;
if(audit.firstBlockedCount<audit.firstBlocked.size())
{
audit.firstBlocked[audit.firstBlockedCount++]={xMetres,yMetres,zMetres,density};
@@ -3602,7 +3608,8 @@ namespace StandaloneStreamBenchmark
}
const auto passageInteriorWinsAt=[&](double xMetres,double yMetres,
double zMetres,std::size_t ignoredPassage=std::numeric_limits<std::size_t>::max(),
std::size_t ignoredSegment=std::numeric_limits<std::size_t>::max())
std::size_t ignoredSegment=std::numeric_limits<std::size_t>::max(),
std::size_t selectedPassage=std::numeric_limits<std::size_t>::max())
{
constexpr double CornerBlendMetres=0.50;
constexpr double WallReliefMetres=0.21;
@@ -3616,6 +3623,8 @@ namespace StandaloneStreamBenchmark
for(std::size_t passageIndex=0;
passageIndex<ResolvedLayout->passages.size();++passageIndex)
{
if(selectedPassage!=std::numeric_limits<std::size_t>::max()
&&passageIndex!=selectedPassage)continue;
const auto& passage=ResolvedLayout->passages[passageIndex];
if(passage.controlPoints.size()<2)continue;
const auto& route=allPassageSmoothRoutes[passageIndex];
@@ -4183,8 +4192,9 @@ namespace StandaloneStreamBenchmark
}
return best;
};
const auto appendDetrendedProfile=[&](const std::vector<double>& values,
double startDistance,std::vector<std::array<double,2>>& output)
const auto appendDetrendedProfile=[&](
const std::vector<std::array<double,2>>& values,
std::vector<std::array<double,2>>& output)
{
if(values.size()<64)return;
// Remove a smooth mouth taper across each 32 m window while
@@ -4193,11 +4203,12 @@ namespace StandaloneStreamBenchmark
// 0.5–8 m periods that this audit is meant to detect.
constexpr std::size_t Degree=3;
std::array<std::array<double,Degree+2>,Degree+1> normal{};
const double meanIndex=0.5*static_cast<double>(values.size()-1);
const double halfSpan=std::max(1.0,meanIndex);
for(std::size_t i=0;i<values.size();++i)
const double meanDistance=0.5*(values.front()[0]+values.back()[0]);
const double halfSpan=std::max(1.0,
0.5*(values.back()[0]-values.front()[0]));
for(const auto& value:values)
{
const double x=(static_cast<double>(i)-meanIndex)/halfSpan;
const double x=(value[0]-meanDistance)/halfSpan;
std::array<double,2*Degree+1> powers{};
powers[0]=1.0;
for(std::size_t power=1;power<powers.size();++power)
@@ -4206,7 +4217,7 @@ namespace StandaloneStreamBenchmark
{
for(std::size_t column=0;column<=Degree;++column)
normal[row][column]+=powers[row+column];
normal[row][Degree+1]+=values[i]*powers[row];
normal[row][Degree+1]+=value[1]*powers[row];
}
}
for(std::size_t column=0;column<=Degree;++column)
@@ -4228,14 +4239,13 @@ namespace StandaloneStreamBenchmark
normal[row][value]-=scale*normal[column][value];
}
}
for(std::size_t i=0;i<values.size();++i)
for(const auto& value:values)
{
const double x=(static_cast<double>(i)-meanIndex)/halfSpan;
const double x=(value[0]-meanDistance)/halfSpan;
double trend=normal[Degree][Degree+1];
for(std::size_t coefficient=Degree;coefficient-->0;)
trend=trend*x+normal[coefficient][Degree+1];
output.push_back({startDistance+static_cast<double>(i)*SampleSpacingMetres,
values[i]-trend});
output.push_back({value[0],value[1]-trend});
}
};
const auto appendDetrendedPairs=[](
@@ -4258,7 +4268,7 @@ namespace StandaloneStreamBenchmark
output.push_back({value[0],value[1]-meanY
-slope*(value[0]-meanX)});
};
std::vector<double> beadControl;
std::vector<std::array<double,2>> beadControl;
beadControl.reserve(static_cast<std::size_t>(WindowLengthMetres/SampleSpacingMetres)+1);
constexpr double BeadSpacingMetres=1.5;
constexpr double BeadSphereRadiusMetres=2.0;
@@ -4266,14 +4276,50 @@ namespace StandaloneStreamBenchmark
{
const double x=static_cast<double>(i)*SampleSpacingMetres;
const double nearest=std::abs(std::remainder(x,BeadSpacingMetres));
beadControl.push_back(std::sqrt(std::max(0.0,
BeadSphereRadiusMetres*BeadSphereRadiusMetres-nearest*nearest)));
beadControl.push_back({x,std::sqrt(std::max(0.0,
BeadSphereRadiusMetres*BeadSphereRadiusMetres-nearest*nearest))});
}
std::vector<std::array<double,2>> beadSamples;
appendDetrendedProfile(beadControl,0.0,beadSamples);
appendDetrendedProfile(beadControl,beadSamples);
double ignoredPeriod=0.0;
audit.controlAmplitudeMetres=sinusoidAmplitude(beadSamples,ignoredPeriod);
audit.controlDetected=audit.controlAmplitudeMetres>=RippleAmplitudeLimitMetres;
std::vector<std::array<double,2>> maskedSineControl,maskedSmoothControl;
constexpr double SamplingControlGapStartMetres=10.0;
constexpr double SamplingControlGapEndMetres=15.0;
for(std::size_t sample=0;
sample<=static_cast<std::size_t>(WindowLengthMetres/SampleSpacingMetres);
++sample)
{
const double distance=static_cast<double>(sample)*SampleSpacingMetres;
if(distance>=SamplingControlGapStartMetres
&&distance<SamplingControlGapEndMetres)continue;
const double phase=6.2831853071795864769*distance/4.0;
maskedSineControl.push_back({distance,0.060*std::sin(phase)});
const double x=(distance-16.0)/16.0;
maskedSmoothControl.push_back({distance,
0.4*x*x*x-0.15*x*x+0.08*x});
}
std::vector<std::array<double,2>> maskedSineResiduals,maskedSmoothResiduals;
appendDetrendedProfile(maskedSineControl,maskedSineResiduals);
appendDetrendedProfile(maskedSmoothControl,maskedSmoothResiduals);
double maskedSinePeriod=0.0,maskedSmoothPeriod=0.0;
const double maskedSineAmplitude=sinusoidAmplitude(
maskedSineResiduals,maskedSinePeriod);
const double maskedSmoothAmplitude=sinusoidAmplitude(
maskedSmoothResiduals,maskedSmoothPeriod);
const bool maskedSamplingControlPassed=
maskedSineAmplitude>=RippleAmplitudeLimitMetres
&&maskedSmoothAmplitude<RippleAmplitudeLimitMetres;
std::printf("[PassageRippleSamplingControl] missing_samples=%zu "
"sine_amplitude_m=%.4f sine_detected=%s smooth_amplitude_m=%.4f "
"smooth_rejected=%s status=%s\n",
static_cast<std::size_t>((SamplingControlGapEndMetres
-SamplingControlGapStartMetres)/SampleSpacingMetres),
maskedSineAmplitude,maskedSineAmplitude>=RippleAmplitudeLimitMetres
?"true":"false",maskedSmoothAmplitude,
maskedSmoothAmplitude<RippleAmplitudeLimitMetres?"true":"false",
maskedSamplingControlPassed?"PASS":"FAIL");
audit.floorControlAmplitudeMetres=audit.controlAmplitudeMetres;
audit.floorControlDetected=audit.floorControlAmplitudeMetres
>=FloorRippleAmplitudeLimitMetres;
@@ -4327,7 +4373,7 @@ namespace StandaloneStreamBenchmark
for(const double fraction:windowStarts)
{
const double start=(total-WindowLengthMetres)*fraction;
std::vector<double> radii;
std::vector<std::array<double,2>> radii;
radii.reserve(static_cast<std::size_t>(WindowLengthMetres/SampleSpacingMetres)+1);
std::size_t wallProbeNonfinite=0,wallProbeOutOfBand=0;
double wallProbeMinimum=std::numeric_limits<double>::infinity();
@@ -4428,7 +4474,7 @@ namespace StandaloneStreamBenchmark
// radius back to the signed wall distance so radius-carried ribs
// remain visible; the cubic detrend removes the smooth mouth flare.
const double measuredRadius=sampleRadius+0.5*(left+right);
radii.push_back(measuredRadius);
radii.push_back({distance,measuredRadius});
++audit.samples;
}
if(radii.size()<static_cast<std::size_t>(WindowLengthMetres/
@@ -4449,7 +4495,7 @@ namespace StandaloneStreamBenchmark
audit.wallWindowExpectedSamples+=static_cast<std::size_t>(
WindowLengthMetres/SampleSpacingMetres)+1;
std::vector<std::array<double,2>> windowSamples;
appendDetrendedProfile(radii,start,windowSamples);
appendDetrendedProfile(radii,windowSamples);
double localPeriod=0.0;
const double localAmplitude=sinusoidAmplitude(windowSamples,localPeriod);
std::printf("[PassageWallRippleWindow] id=%s start_m=%.3f "
@@ -4516,7 +4562,8 @@ namespace StandaloneStreamBenchmark
// probe has no zero crossing. Judge ripple only in windows with
// enough measured wall samples; naturalness separately requires
// visible relief on the route as a whole.
audit.passed=audit.controlDetected&&audit.wallQualifiedWindows>0
audit.passed=audit.controlDetected&&maskedSamplingControlPassed
&&audit.wallQualifiedWindows>0
&&wallWindowCoverage>=0.75
&&audit.localPeakAmplitudeMetres<RippleAmplitudeLimitMetres
&&audit.floorControlDetected&&audit.floorStepControlDetected
@@ -4901,6 +4948,8 @@ namespace StandaloneStreamBenchmark
&&zUm<stratum->content.topMicrometres;
};
std::uint64_t passageCount=0,passagePasses=0,blockedControls=0,naturalPasses=0;
std::uint64_t passageInteriorCapsuleSamples=0,passageInteriorSolidSamples=0;
std::uint64_t passageInteriorControls=0;
std::uint64_t mouthProfilePasses=0,ripplePasses=0,rippleControlsDetected=0;
std::uint64_t floorRippleControlsDetected=0,floorStepRippleControlsDetected=0;
std::uint64_t shellAudits=0,shellFloorSamples=0,shellFloorViolations=0;
@@ -4924,8 +4973,18 @@ namespace StandaloneStreamBenchmark
const std::function<bool(double,double,double)> passageSupportExemption=
[&](double x,double y,double z)
{return passageInteriorWinsAt(x,y,z-0.25);};
const std::function<bool(double,double,double)> passageInteriorPredicate=
[&](double x,double y,double z)
{return passageInteriorWinsAt(x,y,z,
std::numeric_limits<std::size_t>::max(),
std::numeric_limits<std::size_t>::max(),passageIndex);};
const FWalkAudit passageAudit=auditPlayerPath(Shape,path,0.375,0.125,
1.125,3,0.45,passageSupportExemption);
1.125,3,0.45,passageSupportExemption,passageInteriorPredicate);
const bool passageInteriorAirPassed=
passageAudit.passageInteriorCapsuleSamples>0
&&passageAudit.passageInteriorSolidSamples==0;
passageInteriorCapsuleSamples+=passageAudit.passageInteriorCapsuleSamples;
passageInteriorSolidSamples+=passageAudit.passageInteriorSolidSamples;
const FPassageNaturalnessAudit naturalAudit=
auditPassageNaturalness(Shape,passageIndex);
const auto lowerProfileStratum=std::find_if(ResolvedLayout->strates.begin(),
@@ -4984,13 +5043,17 @@ namespace StandaloneStreamBenchmark
rippleControlsDetected+=rippleAudit.controlDetected;
floorRippleControlsDetected+=rippleAudit.floorControlDetected;
floorStepRippleControlsDetected+=rippleAudit.floorStepControlDetected;
passagePasses+=passageAudit.passed&&mouthsInRadius&&mouthsInContent
passagePasses+=passageAudit.passed&&passageInteriorAirPassed
&&mouthsInRadius&&mouthsInContent
&&naturalAudit.passed&&mouthProfileAudit.passed&&rippleAudit.passed;
std::printf("[ResolvedPassageAudit] id=%s interface=%d-%d control_points=%zu center_samples=%llu capsule_samples=%llu blocked=%llu support_samples=%llu support_overlap_skips=%llu unsupported=%llu grade_failures=%llu mouth_content=%d/2 mouth_radius=%d/2 walkability=%s\n",
std::printf("[ResolvedPassageAudit] id=%s interface=%d-%d control_points=%zu center_samples=%llu capsule_samples=%llu blocked=%llu passage_interior_capsule_samples=%llu passage_interior_solid_samples=%llu interior_air=%s support_samples=%llu support_overlap_skips=%llu unsupported=%llu grade_failures=%llu mouth_content=%d/2 mouth_radius=%d/2 walkability=%s\n",
passage.stableId.c_str(),passage.upperStrateIndex,passage.lowerStrateIndex,
passage.controlPoints.size(),static_cast<unsigned long long>(passageAudit.centers),
static_cast<unsigned long long>(passageAudit.capsuleSamples),
static_cast<unsigned long long>(passageAudit.blocked),
static_cast<unsigned long long>(passageAudit.passageInteriorCapsuleSamples),
static_cast<unsigned long long>(passageAudit.passageInteriorSolidSamples),
passageInteriorAirPassed?"PASS":"FAIL",
static_cast<unsigned long long>(passageAudit.supportSamples),
static_cast<unsigned long long>(passageAudit.supportOverlapSkips),
static_cast<unsigned long long>(passageAudit.unsupported),
@@ -5355,13 +5418,38 @@ namespace StandaloneStreamBenchmark
path.push_back({point.x/coreMetres,point.y/coreMetres,
playerZ/coreMetres});
}
const std::function<bool(double,double,double)> passageInteriorPredicate=
[&](double x,double y,double z)
{return passageInteriorWinsAt(x,y,z,
std::numeric_limits<std::size_t>::max(),
std::numeric_limits<std::size_t>::max(),passageIndex);};
const FWalkAudit blockedAudit=auditPlayerPath(blockedWorld,path,
0.125,0.125,0.25,3,0.45);
0.125,0.125,0.25,3,0.45,{},passageInteriorPredicate);
blockedControls+=blockedAudit.blocked>0&&!blockedAudit.passed;
const bool passageInteriorControlDetected=
blockedAudit.passageInteriorCapsuleSamples>0
&&blockedAudit.passageInteriorSolidSamples>0;
passageInteriorControls+=passageInteriorControlDetected;
std::printf("[ResolvedPassageBlockedControl] id=%s blocked_capsule_samples=%llu detected=%s\n",
passage.stableId.c_str(),static_cast<unsigned long long>(blockedAudit.blocked),
blockedAudit.blocked>0&&!blockedAudit.passed?"true":"false");
std::printf("[ResolvedPassageInteriorNegativeControl] id=%s passage_interior_capsule_samples=%llu interior_solid_samples=%llu detected=%s status=%s\n",
passage.stableId.c_str(),
static_cast<unsigned long long>(blockedAudit.passageInteriorCapsuleSamples),
static_cast<unsigned long long>(blockedAudit.passageInteriorSolidSamples),
passageInteriorControlDetected?"true":"false",
passageInteriorControlDetected?"PASS":"FAIL");
}
const bool passageInteriorAuditPassed=passageCount>0
&&passageInteriorCapsuleSamples>0&&passageInteriorSolidSamples==0
&&passageInteriorControls==passageCount;
std::printf("[PassageInteriorCapsuleAuditSummary] interfaces=%llu capsule_samples=%llu solid_samples=%llu negative_controls=%llu/%llu status=%s\n",
static_cast<unsigned long long>(passageCount),
static_cast<unsigned long long>(passageInteriorCapsuleSamples),
static_cast<unsigned long long>(passageInteriorSolidSamples),
static_cast<unsigned long long>(passageInteriorControls),
static_cast<unsigned long long>(passageCount),
passageInteriorAuditPassed?"PASS":"FAIL");
const bool shellAuditPassed=shellAudits==passageCount
&&shellFloorViolations==0&&shellWallViolations==0
&&shellInteriorViolations==0&&shellOpenAirSamples>0;
@@ -5401,6 +5489,7 @@ namespace StandaloneStreamBenchmark
floorStepRippleControlsDetected==passageCount?"DETECTED":"MISSED",
ripplePasses==passageCount?"PASS":"FAIL");
const bool auditPassed=passageCount>0&&passagePasses==passageCount
&&passageInteriorAuditPassed
&&naturalPasses==passageCount&&l23SmoothWallDetected
&&mouthProfilePasses==passageCount&&l23TerraceControlDetected
&&ripplePasses==passageCount