feat(core): native lattice generator, slice 1 -- helix-ramp spine + small maze (L58); research R27
Core.Lattice.PrimitiveField v1, opt-in per strate (legacy Maze/VerticalShaft stay legacy): resolves the real arrival and departure mouths first, plans a mandatory spine, then maze cells and two dead ends (9 rooms, 9 edges, stable IDs). The spine descends 20 m through four helix turns (6 m radius, 3 m clear width, 5 m pitch, 2.6 m clearance; max grade 10.0 deg); each feature is one filleted void (0.57 m measured). Final-field reachability passes at 883 stations; an orphaned shaft control is rejected; exact intervals (0 misses) and a whole-surface audit with 0 flags. Whole view 1.69 s (above the 1 s target). fast/medium/full PASS. Research R27 (self-checked): static stream-to-pool water design. 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
1 parent
1e3e04bbac
commit
6c6cc37e1d
25 files changed
+280497
-117
No files matched your search
@@ -1403,6 +1403,342 @@ namespace StandaloneStreamBenchmark
|
||||
return reachable&&intervalOk&&measured>=0.5;
|
||||
}
|
||||
|
||||
inline bool AuditNativeLatticeField(const VoxelForgeCore::World& shape,
|
||||
const VoxelForgeCore::ResolvedLayoutSnapshotV3& layout,
|
||||
std::uint32_t voxelMicrometres,bool orphanControl)
|
||||
{
|
||||
using namespace VoxelForgeCore;
|
||||
constexpr double Pi=3.1415926535897932384626433832795;
|
||||
constexpr double Q=static_cast<double>(WorldAssemblySubvoxelsPerVoxel);
|
||||
constexpr double MouthCenterHeight=1.13;
|
||||
const double vm=std::max<std::uint32_t>(1,voxelMicrometres)/1.0e6;
|
||||
const auto metres=[](const std::array<std::int64_t,3>& p)
|
||||
{return std::array<double,3>{p[0]/1.0e6,p[1]/1.0e6,p[2]/1.0e6};};
|
||||
const auto density=[&](double x,double y,double z)
|
||||
{return static_cast<double>(shape.densityAt({x/vm,y/vm,z/vm}))*vm;};
|
||||
const auto lattice=std::find_if(layout.strates.begin(),layout.strates.end(),
|
||||
[](const auto& s){return IsNativeLatticeFieldStratum(s)
|
||||
&&s.passageCapabilities.hasNativeLatticeField;});
|
||||
if(lattice==layout.strates.end()||layout.cavernGraphVocabularyVersion!=1)
|
||||
{std::printf("[LatticeAudit] recipe=%s graph=%u status=FAIL\n",
|
||||
lattice==layout.strates.end()?"missing":"present",
|
||||
layout.cavernGraphVocabularyVersion);return false;}
|
||||
const ResolvedLayoutPassageV1* arrival=nullptr;
|
||||
const ResolvedLayoutPassageV1* departure=nullptr;
|
||||
for(const auto& passage:layout.passages)
|
||||
{
|
||||
if(passage.lowerStrateIndex==lattice->strateIndex)
|
||||
{if(arrival)return false;arrival=&passage;}
|
||||
if(passage.upperStrateIndex==lattice->strateIndex)
|
||||
{if(departure)return false;departure=&passage;}
|
||||
}
|
||||
if(!arrival||!departure)return false;
|
||||
const auto mouthMetres=[&](const std::array<std::int64_t,3>& point)
|
||||
{return std::array<double,3>{point[0]*vm/Q,point[1]*vm/Q,
|
||||
point[2]*vm/Q-MouthCenterHeight};};
|
||||
const auto arrivalPoint=mouthMetres(arrival->lowerMouthSubvoxels);
|
||||
const auto departurePoint=mouthMetres(departure->upperMouthSubvoxels);
|
||||
std::vector<const ResolvedCavernEdgeV1*> mazeEdges;
|
||||
const ResolvedCavernEdgeV1* arrivalPortal=nullptr;
|
||||
const ResolvedCavernEdgeV1* helix=nullptr;
|
||||
const ResolvedCavernEdgeV1* departurePortal=nullptr;
|
||||
for(const auto& edge:layout.cavernEdges)
|
||||
{
|
||||
if(edge.strateIndex!=lattice->strateIndex)continue;
|
||||
if(edge.stableId=="lattice/spine/00-arrival-portal-v1")arrivalPortal=&edge;
|
||||
else if(edge.stableId=="lattice/spine/01-helix-ramp-v1")helix=&edge;
|
||||
else if(edge.stableId=="lattice/spine/99-departure-portal-v1")departurePortal=&edge;
|
||||
else if(edge.stableId.starts_with("lattice/spine/maze-edge-"))mazeEdges.push_back(&edge);
|
||||
}
|
||||
std::sort(mazeEdges.begin(),mazeEdges.end(),[](const auto* a,const auto* b)
|
||||
{return a->stableId<b->stableId;});
|
||||
if(!arrivalPortal||!helix||!departurePortal||mazeEdges.size()<4
|
||||
||layout.cavernRooms.size()<mazeEdges.size()+1)return false;
|
||||
std::vector<const ResolvedCavernEdgeV1*> ordered={arrivalPortal,helix};
|
||||
ordered.insert(ordered.end(),mazeEdges.begin(),mazeEdges.end());
|
||||
ordered.push_back(departurePortal);
|
||||
std::vector<std::array<double,3>> route;
|
||||
bool continuous=true;
|
||||
std::size_t pointCount=0;
|
||||
for(const auto* edge:ordered)
|
||||
{
|
||||
if(edge->polylineMicrometres.size()<2)return false;
|
||||
for(std::size_t i=0;i<edge->polylineMicrometres.size();++i)
|
||||
{
|
||||
const auto point=metres(edge->polylineMicrometres[i]);
|
||||
if(!route.empty())
|
||||
{
|
||||
const auto& prior=route.back();
|
||||
const double gap=std::hypot(std::hypot(point[0]-prior[0],point[1]-prior[1]),
|
||||
point[2]-prior[2]);
|
||||
if(i==0&&gap>0.05)continuous=false;
|
||||
if(i==0&&gap<=0.05)continue;
|
||||
}
|
||||
route.push_back(point);++pointCount;
|
||||
}
|
||||
}
|
||||
const auto endpointGap=[](const auto& a,const auto& b)
|
||||
{return std::hypot(std::hypot(a[0]-b[0],a[1]-b[1]),a[2]-b[2]);};
|
||||
const double arrivalGap=endpointGap(metres(arrivalPortal->polylineMicrometres.front()),
|
||||
arrivalPoint);
|
||||
const double departureGap=endpointGap(metres(departurePortal->polylineMicrometres.back()),
|
||||
departurePoint);
|
||||
continuous=continuous&&arrivalGap<=0.05&&departureGap<=0.05;
|
||||
|
||||
double maximumGrade=0.0;
|
||||
for(std::size_t i=1;i<route.size();++i)
|
||||
{
|
||||
const double horizontal=std::hypot(route[i][0]-route[i-1][0],
|
||||
route[i][1]-route[i-1][1]);
|
||||
const double vertical=std::abs(route[i][2]-route[i-1][2]);
|
||||
if(horizontal<1.0e-9&&vertical>1.0e-6)maximumGrade=90.0;
|
||||
else if(horizontal>1.0e-9)
|
||||
maximumGrade=std::max(maximumGrade,std::atan2(vertical,horizontal)*180.0/Pi);
|
||||
}
|
||||
constexpr double CenterlineRadius=6.0,ClearWidth=3.0,Pitch=5.0;
|
||||
const double helixInnerGrade=std::atan(Pitch/
|
||||
(2.0*Pi*(CenterlineRadius-ClearWidth*0.5)))*180.0/Pi;
|
||||
maximumGrade=std::max(maximumGrade,helixInnerGrade);
|
||||
|
||||
std::uint64_t stationCount=0,capsuleSamples=0,supportSamples=0,headSamples=0;
|
||||
std::uint64_t capsuleFailures=0,supportFailures=0,headFailures=0;
|
||||
std::array<double,3> firstCapsuleFailure{},firstSupportFailure{},firstHeadFailure{};
|
||||
bool hasCapsuleFailure=false,hasSupportFailure=false,hasHeadFailure=false;
|
||||
double minimumHeadroom=std::numeric_limits<double>::infinity();
|
||||
bool capsuleClear=continuous,allSupported=continuous,headroomClear=continuous;
|
||||
if(continuous)
|
||||
{
|
||||
constexpr double CapsuleRadius=0.34,CapsuleHeight=1.76,StationStep=0.25;
|
||||
constexpr std::array<std::array<double,2>,5> offsets={{{0.0,0.0},{0.20,0.0},
|
||||
{-0.20,0.0},{0.0,0.20},{0.0,-0.20}}};
|
||||
for(std::size_t segment=1;segment<route.size();++segment)
|
||||
{
|
||||
const auto& a=route[segment-1];const auto& b=route[segment];
|
||||
const double dx=b[0]-a[0],dy=b[1]-a[1],dz=b[2]-a[2];
|
||||
const double length=std::hypot(std::hypot(dx,dy),dz);
|
||||
const int steps=std::max(1,static_cast<int>(std::ceil(length/StationStep)));
|
||||
for(int step=0;step<steps;++step)
|
||||
{
|
||||
const double t=static_cast<double>(step)/steps;
|
||||
const double x=a[0]+dx*t,y=a[1]+dy*t,z=a[2]+dz*t;
|
||||
const double horizontal=std::hypot(dx,dy);
|
||||
const double nx=horizontal>1.0e-9?-dy/horizontal:0.0;
|
||||
const double ny=horizontal>1.0e-9?dx/horizontal:1.0;
|
||||
++stationCount;
|
||||
for(double h=0.10;h<=CapsuleHeight+1.0e-9;h+=0.17)
|
||||
{
|
||||
double cap=0.0;
|
||||
if(h<CapsuleRadius)cap=CapsuleRadius-h;
|
||||
else if(h>CapsuleHeight-CapsuleRadius)
|
||||
cap=h-(CapsuleHeight-CapsuleRadius);
|
||||
const double reach=std::sqrt(std::max(0.0,
|
||||
CapsuleRadius*CapsuleRadius-cap*cap));
|
||||
for(const auto& offset:offsets)
|
||||
{
|
||||
if(std::hypot(offset[0],offset[1])>reach+1.0e-8)continue;
|
||||
++capsuleSamples;
|
||||
const bool clear=density(x+nx*offset[0]-ny*offset[1],
|
||||
y+ny*offset[0]+nx*offset[1],z+0.12+h)>=0.0;
|
||||
capsuleClear=capsuleClear&&clear;
|
||||
if(!clear)
|
||||
{
|
||||
++capsuleFailures;
|
||||
if(!hasCapsuleFailure)
|
||||
{firstCapsuleFailure={x,y,z+0.12+h};hasCapsuleFailure=true;}
|
||||
}
|
||||
}
|
||||
}
|
||||
constexpr std::array<std::array<double,2>,5> supportOffsets={{{0.0,0.0},
|
||||
{0.28,0.0},{-0.28,0.0},{0.0,0.28},{0.0,-0.28}}};
|
||||
for(const auto& offset:supportOffsets)
|
||||
{
|
||||
++supportSamples;bool supported=false;
|
||||
for(double depth=0.08;depth<=0.62+1.0e-9;depth+=0.06)
|
||||
supported=supported||density(x+nx*offset[0]-ny*offset[1],
|
||||
y+ny*offset[0]+nx*offset[1],z-depth)<0.0;
|
||||
allSupported=allSupported&&supported;
|
||||
if(!supported)
|
||||
{
|
||||
++supportFailures;
|
||||
if(!hasSupportFailure)
|
||||
{firstSupportFailure={x+nx*offset[0]-ny*offset[1],
|
||||
y+ny*offset[0]+nx*offset[1],z};hasSupportFailure=true;}
|
||||
}
|
||||
}
|
||||
for(const auto& offset:offsets)
|
||||
{
|
||||
++headSamples;
|
||||
const double clearance=density(x+nx*offset[0]-ny*offset[1],
|
||||
y+ny*offset[0]+nx*offset[1],z+2.20);
|
||||
headroomClear=headroomClear&&clearance>=0.0;
|
||||
if(clearance<0.0)
|
||||
{
|
||||
++headFailures;
|
||||
if(!hasHeadFailure)
|
||||
{firstHeadFailure={x+nx*offset[0]-ny*offset[1],
|
||||
y+ny*offset[0]+nx*offset[1],z+2.20};hasHeadFailure=true;}
|
||||
}
|
||||
if(clearance>=0.0)minimumHeadroom=std::min(minimumHeadroom,2.20);
|
||||
else minimumHeadroom=std::min(minimumHeadroom,0.0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if(hasSupportFailure)
|
||||
{
|
||||
std::printf("[LatticeSupportProbe] first_xyz_m=(%.3f,%.3f,%.3f) density_below_m=",
|
||||
firstSupportFailure[0],firstSupportFailure[1],firstSupportFailure[2]);
|
||||
for(double depth=0.08;depth<=0.62+1.0e-9;depth+=0.06)
|
||||
std::printf("%s%.3f",depth>0.08?",":"",
|
||||
density(firstSupportFailure[0],firstSupportFailure[1],
|
||||
firstSupportFailure[2]-depth));
|
||||
std::printf("\n");
|
||||
}
|
||||
|
||||
const auto filletEdge=mazeEdges.front();
|
||||
const auto p0=metres(filletEdge->polylineMicrometres[
|
||||
filletEdge->polylineMicrometres.size()/2-1]);
|
||||
const auto p1=metres(filletEdge->polylineMicrometres[
|
||||
filletEdge->polylineMicrometres.size()/2]);
|
||||
const double tx=p1[0]-p0[0],ty=p1[1]-p0[1];
|
||||
const double horizontal=std::hypot(tx,ty);
|
||||
const double grade=horizontal>1.0e-9?(p1[2]-p0[2])/horizontal:0.0;
|
||||
const double width=filletEdge->smoothWidthMicrometres/1.0e6;
|
||||
double measuredFillet=0.0;
|
||||
if(horizontal>1.0e-9&&width>0.0)
|
||||
{
|
||||
const double nx=-ty/horizontal,ny=tx/horizontal;
|
||||
const double inverseLength=1.0/std::sqrt(1.0+grade*grade);
|
||||
const double upX=-grade*tx/horizontal*inverseLength;
|
||||
const double upY=-grade*ty/horizontal*inverseLength;
|
||||
const double upZ=inverseLength;
|
||||
const double cx=(p0[0]+p1[0])*0.5,cy=(p0[1]+p1[1])*0.5,
|
||||
cz=(p0[2]+p1[2])*0.5;
|
||||
const double radius=filletEdge->boreRadiusMicrometres/1.0e6;
|
||||
const auto contour=[&](double v)
|
||||
{
|
||||
double lo=0.0,hi=width;
|
||||
const auto sample=[&](double u)
|
||||
{
|
||||
const double inside=(u+v)/std::sqrt(2.0);
|
||||
const double rise=(u-v)/std::sqrt(2.0);
|
||||
return density(cx+nx*(radius-inside)+upX*rise,
|
||||
cy+ny*(radius-inside)+upY*rise,cz+upZ*rise);
|
||||
};
|
||||
if(!(sample(lo)<0.0&&sample(hi)>=0.0))
|
||||
return std::numeric_limits<double>::quiet_NaN();
|
||||
for(int iteration=0;iteration<28;++iteration)
|
||||
{const double mid=(lo+hi)*0.5;if(sample(mid)<0.0)lo=mid;else hi=mid;}
|
||||
return (lo+hi)*0.5;
|
||||
};
|
||||
constexpr double delta=0.02;
|
||||
const double left=contour(-delta),center=contour(0.0),right=contour(delta);
|
||||
if(std::isfinite(left)&&std::isfinite(center)&&std::isfinite(right))
|
||||
measuredFillet=delta*delta/(left+right-2.0*center);
|
||||
}
|
||||
const double idealFillet=width/(2.0*std::sqrt(2.0));
|
||||
|
||||
struct FIntervalCheck {const char* name;std::array<double,3> p;};
|
||||
const auto mazeA=metres(mazeEdges.front()->polylineMicrometres.front());
|
||||
const auto mazeB=metres(mazeEdges.front()->polylineMicrometres.back());
|
||||
const std::array<double,3> mazeMid={(mazeA[0]+mazeB[0])*0.5,
|
||||
(mazeA[1]+mazeB[1])*0.5,(mazeA[2]+mazeB[2])*0.5};
|
||||
const double mazeLength=std::hypot(mazeB[0]-mazeA[0],mazeB[1]-mazeA[1]);
|
||||
const double wallX=mazeLength>1.0e-9?-(mazeB[1]-mazeA[1])/mazeLength:1.0;
|
||||
const double wallY=mazeLength>1.0e-9?(mazeB[0]-mazeA[0])/mazeLength:0.0;
|
||||
double maxX=-std::numeric_limits<double>::infinity();
|
||||
double minY=std::numeric_limits<double>::infinity();
|
||||
double maxY=-std::numeric_limits<double>::infinity();
|
||||
double midZ=mazeMid[2];
|
||||
for(const auto& edge:layout.cavernEdges)if(edge.strateIndex==lattice->strateIndex)
|
||||
for(const auto& point:edge.polylineMicrometres)
|
||||
{const auto p=metres(point);maxX=std::max(maxX,p[0]);minY=std::min(minY,p[1]);maxY=std::max(maxY,p[1]);}
|
||||
const std::array<FIntervalCheck,4> checks={{{"host-rock",{maxX+8.0,
|
||||
(minY+maxY)*0.5,midZ+1.2}},
|
||||
{"maze-air",{mazeMid[0],mazeMid[1],mazeMid[2]+1.25}},
|
||||
{"maze-wall-foot",{mazeMid[0]+wallX*1.30,mazeMid[1]+wallY*1.30,
|
||||
mazeMid[2]+0.25}},
|
||||
{"helix-air",{helix->polylineMicrometres[helix->polylineMicrometres.size()/2][0]/1.0e6,
|
||||
helix->polylineMicrometres[helix->polylineMicrometres.size()/2][1]/1.0e6,
|
||||
helix->polylineMicrometres[helix->polylineMicrometres.size()/2][2]/1.0e6+1.25}}}};
|
||||
std::uint64_t boxes=0,samples=0,misses=0,allAir=0,allSolid=0,mixed=0;
|
||||
bool falseAllAirRejected=false,falseAllSolidRejected=false,wallMixed=false;
|
||||
bool isTileShapeFreeAware=false,latticeTileFree=false;
|
||||
for(const auto& check:checks)
|
||||
{
|
||||
const Vec3i origin{static_cast<int>(std::llround(check.p[0]/vm)),
|
||||
static_cast<int>(std::llround(check.p[1]/vm)),
|
||||
static_cast<int>(std::llround(check.p[2]/vm))};
|
||||
const TileClass verdict=shape.classifyBox(origin,1,1);
|
||||
bool bruteAir=true,bruteSolid=true;
|
||||
for(int z=0;z<=6;++z)for(int y=0;y<=6;++y)for(int x=0;x<=6;++x)
|
||||
{
|
||||
const double d=density((origin.x-1.0+0.5*x)*vm,
|
||||
(origin.y-1.0+0.5*y)*vm,(origin.z-1.0+0.5*z)*vm);
|
||||
bruteAir=bruteAir&&d>=0.0;bruteSolid=bruteSolid&&d<0.0;++samples;
|
||||
if((verdict==TileClass::allAir&&d<0.0)
|
||||
||(verdict==TileClass::allSolid&&d>=0.0))++misses;
|
||||
}
|
||||
++boxes;allAir+=verdict==TileClass::allAir;
|
||||
allSolid+=verdict==TileClass::allSolid;mixed+=verdict==TileClass::mixed;
|
||||
falseAllAirRejected|=bruteSolid&&verdict!=TileClass::allAir;
|
||||
falseAllSolidRejected|=bruteAir&&verdict!=TileClass::allSolid;
|
||||
if(std::string_view(check.name)=="maze-wall-foot")wallMixed=verdict==TileClass::mixed;
|
||||
if(std::string_view(check.name)=="maze-air")
|
||||
{
|
||||
const int32 tileWidth=CoreTileVoxelCount;
|
||||
const TileKey key{{static_cast<std::int32_t>(std::floor(
|
||||
static_cast<double>(origin.x)/tileWidth)),
|
||||
static_cast<std::int32_t>(std::floor(static_cast<double>(origin.y)/tileWidth)),
|
||||
static_cast<std::int32_t>(std::floor(static_cast<double>(origin.z)/tileWidth))},0};
|
||||
latticeTileFree=shape.isTileShapeFree(key);
|
||||
isTileShapeFreeAware=!latticeTileFree;
|
||||
}
|
||||
std::printf("[LatticeIntervalBox] id=%s proof=%s brute_air=%s brute_solid=%s miss=%s\n",
|
||||
check.name,verdict==TileClass::allAir?"all-air":
|
||||
verdict==TileClass::allSolid?"all-solid":"mixed",
|
||||
bruteAir?"yes":"no",bruteSolid?"yes":"no",
|
||||
(verdict==TileClass::allAir?!bruteAir:
|
||||
verdict==TileClass::allSolid?!bruteSolid:false)?"yes":"no");
|
||||
}
|
||||
const bool intervalOk=boxes>=4&&allSolid>=1&&mixed>=1
|
||||
&&misses==0&&falseAllAirRejected&&falseAllSolidRejected&&wallMixed
|
||||
&&isTileShapeFreeAware;
|
||||
const bool pathOk=continuous&&capsuleClear&&allSupported&&headroomClear
|
||||
&&maximumGrade<=15.0&&minimumHeadroom>=2.2;
|
||||
std::printf("[LatticeCapsuleReachability] arrival=%s departure=%s edges=%zu path_points=%zu stations=%llu capsule_samples=%llu capsule_failures=%llu first_capsule_failure_m=(%.3f,%.3f,%.3f) support_samples=%llu support_failures=%llu first_support_failure_m=(%.3f,%.3f,%.3f) head_samples=%llu head_failures=%llu first_head_failure_m=(%.3f,%.3f,%.3f) max_grade_deg=%.3f min_headroom_m=%.3f required_headroom_m=2.200 support=every-station reachable=%s status=%s\n",
|
||||
arrival->stableId.c_str(),departure->stableId.c_str(),ordered.size(),pointCount,
|
||||
static_cast<unsigned long long>(stationCount),
|
||||
static_cast<unsigned long long>(capsuleSamples),
|
||||
static_cast<unsigned long long>(capsuleFailures),firstCapsuleFailure[0],
|
||||
firstCapsuleFailure[1],firstCapsuleFailure[2],
|
||||
static_cast<unsigned long long>(supportSamples),
|
||||
static_cast<unsigned long long>(supportFailures),firstSupportFailure[0],
|
||||
firstSupportFailure[1],firstSupportFailure[2],
|
||||
static_cast<unsigned long long>(headSamples),
|
||||
static_cast<unsigned long long>(headFailures),firstHeadFailure[0],
|
||||
firstHeadFailure[1],firstHeadFailure[2],maximumGrade,
|
||||
minimumHeadroom, pathOk?"yes":"no",pathOk?"PASS":"FAIL");
|
||||
std::printf("[LatticeFilletAudit] smooth_max=cubic width_m=%.6f measured_radius_m=%.6f ideal_radius_m=%.6f status=%s\n",
|
||||
width,measuredFillet,idealFillet,measuredFillet>=0.5?"PASS":"FAIL");
|
||||
std::printf("[LatticeIntervalOracle] boxes=%llu all_air=%llu all_solid=%llu mixed=%llu samples=%llu misses=%llu false_all_air=%s false_all_solid=%s wall_foot=%s isTileShapeFree=%s tile_free=%s status=%s\n",
|
||||
static_cast<unsigned long long>(boxes),static_cast<unsigned long long>(allAir),
|
||||
static_cast<unsigned long long>(allSolid),static_cast<unsigned long long>(mixed),
|
||||
static_cast<unsigned long long>(samples),static_cast<unsigned long long>(misses),
|
||||
falseAllAirRejected?"REJECTED":"FAILED",
|
||||
falseAllSolidRejected?"REJECTED":"FAILED",wallMixed?"mixed":"not-mixed",
|
||||
isTileShapeFreeAware?"BLOCKED":"FAILED",latticeTileFree?"yes":"no",
|
||||
intervalOk?"PASS":"FAIL");
|
||||
if(orphanControl)
|
||||
{
|
||||
const bool rejected=!continuous||!pathOk;
|
||||
std::printf("[LatticeReachabilityControl] orphaned_shaft=true result=%s expected=FAIL status=%s\n",
|
||||
rejected?"FAIL":"PASS",rejected?"PASS":"FAIL");
|
||||
return rejected&&intervalOk&&measuredFillet>=0.5;
|
||||
}
|
||||
return pathOk&&intervalOk&&measuredFillet>=0.5;
|
||||
}
|
||||
|
||||
inline bool AuditMotifIntervals(const VoxelForgeCore::World& shape,
|
||||
const VoxelForgeCore::ResolvedLayoutSnapshotV3& layout,
|
||||
std::uint32_t voxelMicrometres)
|
||||
@@ -1535,7 +1871,8 @@ namespace StandaloneStreamBenchmark
|
||||
bool bInstrumentTileDrain=false,bool bAuditMotifIntervals=false,
|
||||
bool bExactMidpointDensityMemo=false,
|
||||
bool bActiveLaneBatching=false,int32 ProofBlockCells=8,
|
||||
bool bParallelSignEdgeRepair=false)
|
||||
bool bParallelSignEdgeRepair=false,bool bAuditNativeLattice=false,
|
||||
bool bLatticeOrphanControl=false)
|
||||
{
|
||||
using Clock=std::chrono::steady_clock;
|
||||
FStandaloneOwnerWorld& World=*OwnerWorld;
|
||||
@@ -1741,6 +2078,14 @@ namespace StandaloneStreamBenchmark
|
||||
{std::fprintf(stderr,"[CavesAudit] missing resolved layout\n");return 2;}
|
||||
return AuditNativeCavesField(Shape,*ResolvedLayout,World.CoreVoxelSizeMicrons)?0:14;
|
||||
}
|
||||
if(bAuditNativeLattice)
|
||||
{
|
||||
Streamer.Stop();
|
||||
if(!ResolvedLayout||!CoreSnapshot.resolvedLayout())
|
||||
{std::fprintf(stderr,"[LatticeAudit] missing resolved layout\n");return 2;}
|
||||
return AuditNativeLatticeField(Shape,*ResolvedLayout,
|
||||
World.CoreVoxelSizeMicrons,bLatticeOrphanControl)?0:14;
|
||||
}
|
||||
if(bAuditMotifIntervals)
|
||||
{
|
||||
Streamer.Stop();
|
||||
|
||||
Reference in new issue
Block a user