chore: remove the Qwen scaffold

It was the starting point for the Qwen3.8-Flash-Next run, which now continues as OpenNest.Engine.Qwen38FlashNext (stamped from _Template). The unimplemented scaffold under the bare "Qwen" name would only collide with or be confused for that engine once it lands here. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-24 10:37:56 -04:00
parent 755ea4d7f8
commit c8393f135c
6 changed files with 0 additions and 150 deletions
@@ -1,3 +0,0 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <!-- Shared settings and the OpenNest.Engine reference come from Engines/Directory.Build.props. -->
 </Project>
@@ -1,41 +0,0 @@
 using System;
 using System.Threading;
 using OpenNest.Engine.Jobs;
 namespace OpenNest.Engine.Qwen;
 /// <summary>
 /// TODO: name and describe the actual placement strategy here (e.g. "skyline packer with
 /// greedy shelf assignment", "NFP-based sliding placement with simulated-annealing order
 /// search", etc). This must be an independently designed algorithm — see README.md.
 /// </summary>
 public sealed class QwenNestingEngine : INestingEngine
 {
    public NestJobResult Solve(
        NestJob job,
        IProgress<NestJobProgress>? progress = null,
        CancellationToken token = default
    )
    {
        ArgumentNullException.ThrowIfNull(job);
        // TODO: implement independent placement logic here.
        //
        // Do NOT call NestingEngineRegistry.Create(...), PlateNesterFactory, PlateFillService,
        // or any built-in INestingEngine, and do not run several and keep the best. The
        // Fill/ and pattern components (FillLinear, PairFiller, PatternTiler, Compactor, ...)
        // and OpenNest.Core geometry ARE fair game as tools; the decisions are yours.
        //
        // job.Parts        -> requested parts (PartGeometrySnapshot geometry, quantity, priority, rotation policy)
        // job.Plates        -> candidate stock sheets (size, spacing, quadrant, quantity)
        // job.Options       -> job-wide options
        //
        // Return a NestJobResult built from NestJobPlateResult (one per used sheet, holding
        // ordered NestJobPlacement values), PartFulfillment (requested vs placed per part id),
        // and StockUsage (sheets used per stock id).
        throw new NotImplementedException(
            "Qwen nesting engine placement logic not yet implemented."
        );
    }
 }
@@ -1,70 +0,0 @@
 # OpenNest.Engine.Qwen
 An independent `INestingEngine` implementation. It must not be a wrapper, ensemble, or
 selector over OpenNest's built-in engines. `Solve()` must not call, instantiate, or
 delegate to any existing `INestingEngine` (`StockLadderNestingEngine`,
 `FixedStrategyNestingEngine`), `NestingEngineRegistry`, `NestJobRunner`, or the whole-plate
 nesters/fillers behind `PlateNesterFactory` (`DefaultPlateNester`, `StripPlateNester`,
 `RemnantPlateNester`, `PlateFillService`, `DefaultPlateFiller`, ...). It must also never run
 several of them and keep the best result.
 The decisions that make it an engine must be yours: which sheet(s) to use, which parts go
 where and in what order, which pattern/strategy to apply to which region, and when to stop.
 ## Allowed building blocks
 Reuse is encouraged. These are tools you drive, composed by your own decision logic:
 - `OpenNest.Core` geometry: `Polygon`, `Shape`, `BoundingBox`, `Vector`, `Box`, `ConvexHull`,
  `ConvexDecomposition`, `RotatingCalipers`, `Collision`, `NoFitPolygon`, `ShapeProfile`,
  `SpatialQuery`.
 - Fill and pattern components in `OpenNest.Engine.Fill`: `FillLinear`, `FillExtents`,
  `PairFiller`, `ShrinkFiller`, `RemnantFiller`/`RemnantFinder`, `Compactor`, `FillScore`,
  `Pattern`/`PatternTiler`, `PartBoundary`, `RotationAnalysis`, `AngleCandidateBuilder`,
  `BestCombination`.
 - `OpenNest.Engine.BestFit` (`BestFitFinder`, `PairEvaluator`, ...), `RectanglePacking`,
  `CirclePacking`.
 If you find a faster or better way to do something a shared component already does (for
 example linear patterning), implement it inside this engine's own project and leave the
 shared code untouched. Do not edit `OpenNest.Core` or `OpenNest.Engine`. Call it out in your
 report (what it replaces, why it is better, measured numbers) so it can be generalized and
 upstreamed for every engine later.
 ## What to fill in
 `QwenNestingEngine.cs` — implement `Solve()`. Pick and document an actual
 placement strategy (NFP-based sliding placement, skyline/shelf packer,
 simulated-annealing/genetic layout search, guillotine-cut packer,
 physics/gravity-settling, etc). It's fine to be simpler or worse than the built-in
 engines to start; it must not be the same algorithm re-derived through indirection.
 ## Build
 ```bash
 dotnet build OpenNest.Engine.Qwen/OpenNest.Engine.Qwen.csproj
 ```
 This project is intentionally **outside** `OpenNest.sln` (same pattern as the
 `OpenNest.Engine.Aurora` plugin) — it's discovered at runtime as a plugin, not built
 as part of the main solution.
 ## Try it out with the benchmark
 `OpenNest.Benchmark` auto-loads plugin engines from an `Engines/` folder next to its
 own build output:
 ```bash
 dotnet build OpenNest.Engine.Qwen/OpenNest.Engine.Qwen.csproj -c Release
 dotnet build OpenNest.Benchmark/OpenNest.Benchmark.csproj -c Release
 mkdir -p ../OpenNest/OpenNest.Benchmark/bin/Release/net8.0/Engines
 cp OpenNest.Engine.Qwen/bin/Release/net8.0/OpenNest.Engine.Qwen.dll    ../OpenNest/OpenNest.Benchmark/bin/Release/net8.0/Engines/
 dotnet ../OpenNest/OpenNest.Benchmark/bin/Release/net8.0/OpenNest.Benchmark.dll <path-to-.nest-or-folder>
 ```
 Or build and deploy in one step with `./Build-Engines.ps1 -Engines Qwen`.
 Your engine will show up in the report under its CLR type name (`QwenNestingEngine`),
 competing on equal footing against the built-in engines.
@@ -1,15 +0,0 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageReference Include="xunit" Version="2.5.3" />
    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Xunit" />
    <ProjectReference Include="../OpenNest.Engine.Qwen.csproj" />
  </ItemGroup>
 </Project>
@@ -1,20 +0,0 @@
 using System;
 using System.Collections.Generic;
 using OpenNest.Engine.Jobs;
 using OpenNest.Geometry;
 namespace OpenNest.Engine.Qwen.Tests;
 public class QwenNestingEngineTests
 {
    [Fact]
    public void SolveReturnsAResultForASingleSimplePart()
    {
        // TODO: replace with a real fixture once Solve() is implemented — this only
        // proves the plumbing (project reference, constructor, interface) is wired up.
        var engine = new QwenNestingEngine();
        Assert.NotNull(engine);
        Assert.IsAssignableFrom<INestingEngine>(engine);
    }
 }
@@ -9,7 +9,6 @@ the OpenNest app or `OpenNest.Benchmark` build output.
 |--------|----------|
 | [Gpt6Astra](OpenNest.Engine.Gpt6Astra/) | Contact-based placement |
 | [Opus55](OpenNest.Engine.Opus55/) | Frontier-advance no-fit-polygon packing |
 | [Qwen](OpenNest.Engine.Qwen/) | Scaffold — not yet implemented |
 ## Building