FIxed bug in coil additioanl turn redisrtribution

Author: AlfVII

src/constructive_models/Coil.cpp

@@ -4791,12 +4791,45 @@ bool Coil::wind_toroidal_additional_turns() {
             double currentBaseRadialHeightForLayers = currentBaseRadialHeight + turnsInSection[0].get_dimensions().value()[0] / 2;
 
             auto layersThisSection = get_layers_by_section(section.get_name());
-            bool areLayersTaped = layersThisSection.size() > 1;
-            for (size_t layerIndex = 0; layerIndex < layersThisSection.size() - 1; ++layerIndex) {
-                if (layersThisSection[layerIndex].get_type() == ElectricalType::CONDUCTION && layersThisSection[layerIndex + 1].get_type() == ElectricalType::CONDUCTION) {
-                    areLayersTaped = false;
+            // Check if there are at least 2 conduction layers with NO real insulation between them
+            // Real insulation = thickness > MIN_INSULATION_THICKNESS
+            const double MIN_INSULATION_THICKNESS = 1e-9;
+            bool areLayersTaped = true;
+            
+            // Find all conduction layer indices
+            std::vector<size_t> conductionLayerIndices;
+            for (size_t i = 0; i < layersThisSection.size(); ++i) {
+                if (layersThisSection[i].get_type() == ElectricalType::CONDUCTION) {
+                    conductionLayerIndices.push_back(i);
+                }
+            }
+            
+            // If we have 2+ conduction layers, check if there's real insulation between any pair
+            if (conductionLayerIndices.size() >= 2) {
+                areLayersTaped = false;  // Assume no tape until we find real insulation
+                
+                for (size_t i = 0; i < conductionLayerIndices.size() - 1; ++i) {
+                    size_t firstCondIdx = conductionLayerIndices[i];
+                    size_t secondCondIdx = conductionLayerIndices[i + 1];
+                    
+                    // Check all layers between these two conduction layers
+                    bool hasRealInsulation = false;
+                    for (size_t j = firstCondIdx + 1; j < secondCondIdx; ++j) {
+                        if (layersThisSection[j].get_type() == ElectricalType::INSULATION) {
+                            double insulationThickness = layersThisSection[j].get_dimensions()[0];
+                            if (insulationThickness > MIN_INSULATION_THICKNESS) {
+                                hasRealInsulation = true;
+                                break;
+                            }
+                        }
+                    }
+                    
+                    if (hasRealInsulation) {
+                        areLayersTaped = true;
+                    }
                 }
             }
+            
             for (auto layer : layersThisSection) {
                 if (layer.get_type() == ElectricalType::CONDUCTION) {
                     auto turnsThisLayer = get_turns_by_layer(layer.get_name());

src/support/BasicPainter.cpp

@@ -919,10 +919,6 @@ void BasicPainter::paint_toroidal_core(Core core) {
     std::string cssClassName = generate_random_string();
     _root.style("." + cssClassName).set_attr("stroke-width", strokeWidth * _scale).set_attr("fill", "none").set_attr("stroke", std::regex_replace(std::string(settings.get_painter_color_ferrite()), std::regex("0x"), "#"));
     paint_circle(0, 0, circleDiameter / 2, cssClassName, nullptr);
-
-    // _root.autoscale();
-    _root.set_attr("width", _imageWidth * _scale).set_attr("height", _imageHeight * _scale);  // TODO remove
-    _root.set_attr("viewBox", std::to_string(-_imageWidth / 2 * _scale) + " " + std::to_string(-_imageHeight / 2 * _scale) + " " + std::to_string(_imageWidth * _scale) + " " + std::to_string(_imageHeight * _scale));  // TODO remove
 }
 
 void BasicPainter::paint_two_piece_set_margin(Magnetic magnetic) {
@@ -2617,6 +2613,10 @@ void BasicPainter::paint_temperature_field(Magnetic magnetic, const std::map<std
 }
 
 std::string BasicPainter::export_svg() {
+    // Autoscale to fit all content before exporting
+    // This ensures proper centering when additional turns extend asymmetrically
+    _root.autoscale();
+    
     if (!_filepath.empty()) {
         if (!std::filesystem::exists(_filepath)) {
             std::filesystem::create_directory(_filepath);

tests/TestCoil.cpp

@@ -9190,8 +9190,7 @@ TEST_CASE("Test_Additiona_Turns_Bug", "[constructive-model][coil][round-winding-
     auto turns = coil.get_turns_description().value();
     auto layers = coil.get_layers_description().value();
 
-    std::cout << "Number of layers: " << layers.size() << std::endl;
-    
+
     // Check that all turns have additional coordinates
     for (auto& turn : turns) {
         REQUIRE(turn.get_additional_coordinates());
@@ -9203,11 +9202,6 @@ TEST_CASE("Test_Additiona_Turns_Bug", "[constructive-model][coil][round-winding-
         turnsByLayer[turns[i].get_layer().value()].push_back(i);
     }
 
-    std::cout << "Turns per layer:" << std::endl;
-    for (auto& [layerName, indices] : turnsByLayer) {
-        std::cout << "  " << layerName << ": " << indices.size() << " turns" << std::endl;
-    }
-    
     // Collect all additional radii
     std::vector<double> additionalRadii;
     for (size_t i = 0; i < turns.size(); ++i) {
@@ -9222,13 +9216,7 @@ TEST_CASE("Test_Additiona_Turns_Bug", "[constructive-model][coil][round-winding-
         // Round to 0.1mm precision
         uniqueRadii.insert(round(r * 10000) / 10000);
     }
-    
-    std::cout << "Unique additional radii: ";
-    for (auto r : uniqueRadii) {
-        std::cout << r * 1000 << "mm ";
-    }
-    std::cout << std::endl;
-    
+
     // The bug was that additional turns from layer 1 were placed at a different radius
     // than turns from layer 0, even though there was space in the first additional layer.
     // After the fix, all additional turns should be at the same radius (compacted).
@@ -10477,4 +10465,75 @@ TEST_CASE("Test_Toroidal_Delimit_And_Compact_Multilayer", "[toroidal][coil][comp
     settings.reset();
 }
 
+TEST_CASE("Test_Coil_Compacting_Tertiary_Winding", "[constructive-model][coil][bug][visualization]") {
+    auto testDataPath = get_test_data_path(std::source_location::current(), "bug_coil_compacting.json");
+    std::ifstream file(testDataPath);
+    REQUIRE(file.good());
+    
+    json j;
+    file >> j;
+    
+    auto magneticJson = j["magnetic"];
+    auto coilJson = magneticJson["coil"];
+    auto coreJson = magneticJson["core"];
+    
+    OpenMagnetics::Coil coil(coilJson);
+    OpenMagnetics::Core core(coreJson);
+    
+    // Enable compacting and additional coordinates
+    settings.set_coil_delimit_and_compact(true);
+    settings.set_coil_include_additional_coordinates(true);
+    
+    // Wind the coil
+    coil.wind();
+    
+    // Check if we have turns
+    REQUIRE(coil.get_turns_description().has_value());
+    auto turns = coil.get_turns_description().value();
+    
+    // Create magnetic for visualization
+    OpenMagnetics::Magnetic magnetic;
+    magnetic.set_coil(coil);
+    magnetic.set_core(core);
+    
+    // Paint the coil with core
+    auto outputFilePath = std::filesystem::path{std::source_location::current().file_name()}.parent_path().append("..").append("output");
+    auto outFile = outputFilePath;
+    outFile.append("Test_Coil_Compacting_Tertiary_Winding.svg");
+    std::filesystem::remove(outFile);
+    
+    Painter painter(outFile);
+    painter.paint_core(magnetic);
+    painter.paint_bobbin(magnetic);
+    painter.paint_coil_sections(magnetic);
+    painter.paint_coil_turns(magnetic);
+    painter.export_svg();
+    
+    // Analyze turns by winding
+    std::map<std::string, std::vector<Turn>> turnsByWinding;
+    for (const auto& turn : turns) {
+        turnsByWinding[turn.get_winding()].push_back(turn);
+    }
+    
+    // Check each winding has additional coordinates
+    for (const auto& [windingName, windingTurns] : turnsByWinding) {
+        int withAdditional = 0;
+        int withoutAdditional = 0;
+        
+        for (const auto& turn : windingTurns) {
+            if (turn.get_additional_coordinates().has_value()) {
+                withAdditional++;
+            } else {
+                withoutAdditional++;
+            }
+        }
+        
+        // All turns should have additional coordinates
+        REQUIRE(withoutAdditional == 0);
+    }
+    
+    settings.reset();
+}
+
+
 }  // namespace