PlotFinderTests.cpp

#if !defined(OFX_IMGUI_ENABLE_TEST_ENGINE)
#error PlotFinderTests requires OFX_IMGUI_ENABLE_TEST_ENGINE - see example-test/config.make
#endif

#include "PlotFinderTests.h"

#include "PlotFinderTestHelpers.h"

#include "FinderCapabilities.h"
#include "FinderProgress.h"
#include "FinderRegistry.h"
#include "PlotFinderTypes.h"
#include "RegionHelpers.h"
#include "RegionTypes.h"

#include "imgui_te_context.h"
#include "imgui_te_engine.h"

#include <algorithm>
#include <cfloat>

namespace {

struct GoldenCase {
	const char*      name;
	PlotFinderType   type;
	int              minPaths;
	int              maxPaths;
	float            minLength;
	float            maxLength;
};

void registerGoldenCase(ImGuiTestEngine* e, const GoldenCase& golden) {
	ImGuiTest* t = IM_REGISTER_TEST(e, "plotfind/golden", golden.name);
	t->UserData = const_cast<GoldenCase*>(&golden);
	t->TestFunc = [](ImGuiTestContext* ctx) {
		const GoldenCase& g = *static_cast<const GoldenCase*>(ctx->Test->UserData);
		const ofPixels checker = plotfind::test::makeCheckerboard(64, 8);
		entt::registry reg;
		PlotDoc doc(reg);
		plotfind::test::setupGoldenLayer(doc, reg, g.type, checker);

		doc.generateLayer(doc.activeLayer);

		const plotfind::test::GenStats stats = plotfind::test::statsFromLayer(reg, doc.activeLayer);
		IM_CHECK_GE(stats.pathCount, g.minPaths);
		IM_CHECK_LE(stats.pathCount, g.maxPaths);
		IM_CHECK_GE(stats.totalLength, g.minLength);
		IM_CHECK_LE(stats.totalLength, g.maxLength);

		const glm::vec2 paper = doc.getPaperSizeMM();
		IM_CHECK_LE(stats.bounds.getWidth(), paper.x + 1.f);
		IM_CHECK_LE(stats.bounds.getHeight(), paper.y + 1.f);
	};
}

} // namespace

void RegisterPlotFinderTests(ImGuiTestEngine* e) {
	ImGuiTest* t = nullptr;

	t = IM_REGISTER_TEST(e, "plotfind/unit", "registry_count");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		IM_CHECK_EQ(plotfind::FinderRegistry::instance().listIds().size(), 20u);
	};

	t = IM_REGISTER_TEST(e, "plotfind/unit", "plot_finder_id_roundtrip");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		for (const auto type : plotfind::test::kAllFinders) {
			const auto id   = plotfind::PlotFinderId::fromType(type);
			const auto back = plotfind::PlotFinderId::toType(id);
			IM_CHECK_EQ(back, type);
		}
	};

	t = IM_REGISTER_TEST(e, "plotfind/unit", "capabilities_table");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		for (const auto type : plotfind::test::kAllFinders) {
			const auto table = plotfind::capabilitiesFor(type);
			const auto live  = plotfind::FinderRegistry::instance().capabilities(type);
			IM_CHECK_EQ(live.partition, table.partition);
			IM_CHECK_EQ(live.strokeRole, table.strokeRole);
			IM_CHECK_EQ(live.declaresFillIntent, table.declaresFillIntent);
			IM_CHECK_EQ(live.canExportRegions, table.canExportRegions);
			IM_CHECK_EQ(live.canBeCompositeSubFinder, table.canBeCompositeSubFinder);
		}
	};

	t = IM_REGISTER_TEST(e, "plotfind/unit", "composite_orchestrator");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		const auto caps = plotfind::capabilitiesFor(PlotFinderType::CompositeFinder);
		IM_CHECK_EQ(caps.canBeCompositeSubFinder, false);
		IM_CHECK_EQ(caps.canExportRegions, true);
	};

	t = IM_REGISTER_TEST(e, "plotfind/unit", "rect_mask");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		const ofRectangle rect(10, 10, 20, 15);
		const auto mask = plotfind::rectMask(64, 64, rect);
		const int inside =
		    (int)std::count_if(mask.begin(), mask.end(), [](unsigned char v) { return v == 255; });
		IM_CHECK_EQ(inside, 20 * 15);
	};

	t = IM_REGISTER_TEST(e, "plotfind/unit", "masked_grey_pixels");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		std::vector<unsigned char> grey(64 * 64, 0);
		std::vector<unsigned char> halfMask(64 * 64, 0);
		for (int y = 0; y < 64; ++y)
			for (int x = 0; x < 32; ++x)
				halfMask[y * 64 + x] = 255;

		const auto masked = plotfind::maskedGreyPixels(grey.data(), 64, 64, halfMask);
		for (int i = 0; i < 64 * 64; ++i) {
			if (halfMask[i] == 0) IM_CHECK_EQ(masked[i], (unsigned char)255);
		}
	};

	t = IM_REGISTER_TEST(e, "plotfind/unit", "average_brightness_in_mask");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		std::vector<unsigned char> grey(64 * 64, 0);
		std::vector<unsigned char> halfMask(64 * 64, 0);
		for (int y = 0; y < 64; ++y)
			for (int x = 0; x < 32; ++x)
				halfMask[y * 64 + x] = 255;

		const float avg = plotfind::averageBrightnessInMask(grey.data(), 64, 64, halfMask);
		IM_CHECK_FLOAT_EQ(avg, 0.f);
	};

	t = IM_REGISTER_TEST(e, "plotfind/unit", "progress_clamp");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		float last = -1.f;
		plotfind::reportProgress(
		    [&](float p, const std::string&) { last = p; }, 1.5f, "high");
		IM_CHECK_LE(last, 1.f);

		plotfind::reportProgress(
		    [&](float p, const std::string&) { last = p; }, -0.5f, "low");
		IM_CHECK_GE(last, 0.f);
	};

	// Bounds are for a 64×64 checkerboard on default A4 paper (see PlotFinderTestHelpers).
	static const GoldenCase goldenCases[] = {
		{"checkerboard_structure_grid", PlotFinderType::GridFinder, 4, 800, 10.f, 25000.f},
		{"checkerboard_hatch_parallel", PlotFinderType::ParallelHatch, 1, 5000, 1.f, 50000.f},
		{"checkerboard_contour_edges", PlotFinderType::Contours, 1, 1200, 1.f, 50000.f},
		{"checkerboard_stipple_dots", PlotFinderType::Stippling, 1, 100000, 1.f, 100000.f},
		{"checkerboard_potrace_regions", PlotFinderType::Potrace, 1, 4000, 1.f, 50000.f},
		{"checkerboard_structure_maze", PlotFinderType::MazeFinder, 1, 1500, 1.f, 12000.f},
	};
	for (const auto& golden : goldenCases) registerGoldenCase(e, golden);

	t = IM_REGISTER_TEST(e, "plotfind/golden", "generate_all_finders");
	t->TestFunc = [](ImGuiTestContext* ctx) {
		(void)ctx;
		const ofPixels checker = plotfind::test::makeCheckerboard(64, 8);
		for (const auto type : plotfind::test::kAllFinders) {
			entt::registry reg;
			PlotDoc doc(reg);
			plotfind::test::setupGoldenLayer(doc, reg, type, checker);
			doc.generateLayer(doc.activeLayer);
			const plotfind::test::GenStats stats = plotfind::test::statsFromLayer(reg, doc.activeLayer);
			IM_CHECK_GE(stats.pathCount, 0);
		}
	};
}