Translate flash_rasterizer.cpp to Java with compound rasterizer and anti-aliased rendering

agg-java/.gitignore

@@ -21,3 +21,8 @@ buildNumber.properties
 # OS
 .DS_Store
 Thumbs.db
+
+# Flash rasterizer output files
+flash_rasterizer_output.ppm
+flash_rasterizer_output.png
+view_output.html

agg-java/COMPOUND_RASTERIZER_IMPLEMENTATION_STATUS.md

@@ -0,0 +1,162 @@
+# Compound Rasterizer Implementation Status
+
+## Overview
+Translating C++ AGG's RasterizerCompoundAa and render_scanlines_compound to Java for perfect polygon stitching in Flash vector shapes.
+
+## Completed Components ✅
+
+### Foundation Classes (commit 71706a1)
+- **CellStyleAa.java** - Cell structure with left/right fill indices
+- **StyleInfo.java** - Per-style cell tracking (start_cell, num_cells, last_x)
+- **CellInfo.java** - Simplified cell data for rendering (x, area, cover)
+
+### Existing Support Classes
+- **ScanlineBin.java** - Binary scanline (fully covered or not)
+- **SpanAllocator.java** - Memory allocation for color spans
+- **ScanlineU8.java** - Anti-aliased scanline with coverage data
+- **Rgba8.java** - RGBA color with blending support
+
+## In Progress 🚧
+
+### RasterizerCompoundAa.java (~600 lines total)
+
+**Completed Methods:**
+- Constructor and initialization
+- reset(), resetClipping(), clipBox()
+- fillingRule(), layerOrder()
+- styles(left, right) - Set current fill styles
+- moveTo(), lineTo(), addVertex()
+- addPath() - Add path from vertex source
+- min/max accessors (minX, maxX, minY, maxY, minStyle, maxStyle)
+- calculateAlpha() - Coverage to alpha conversion
+- sweepScanline() - Generate scanline for specific style
+
+**Still Needed (~300 lines):**
+- **sort()** - Sort cells and prepare for rendering
+- **rewindScanlines()** - Initialize scanline iteration
+- **sweepStyles()** - Build Active Style Table for current scanline (~150 lines)
+  - Complex algorithm with:
+    - Cell iteration
+    - Style accumulation
+    - Left/right fill tracking
+    - Bit mask operations for Active Style Mask
+    - Cell info array building
+- **allocateCoverBuffer()** - Memory management
+- **navigate Scanline()** - Random scanline access
+- **hitTest()** - Point-in-shape testing
+
+## Not Started ❌
+
+### StyleHandler Interface (~30 lines)
+```java
+public interface StyleHandler {
+    boolean isSolid(int style);
+    Rgba8 color(int style);
+    void generateSpan(Rgba8[] span, int x, int y, int len, int style);
+}
+```
+
+### RenderScanlinesCompound (~150 lines)
+```java
+public static void renderScanlinesCompound(
+    RasterizerCompoundAa ras,
+    ScanlineU8 slAa,
+    ScanlineBin slBin,
+    RendererBase ren,
+    SpanAllocator alloc,
+    StyleHandler sh)
+```
+
+Main rendering loop with:
+- Single style optimization (fast path)
+- Multi-style blending (mix buffer + composite)
+- Color span generation
+- Alpha blending logic
+
+### Integration (~100 lines)
+- Update FlashRasterizerExample to use compound rasterizer
+- Implement StyleHandler for test colors
+- Remove flash_rasterizer2 approach code
+- Add shapes.txt test cases
+
+## Technical Challenges
+
+### 1. sweepStyles() Complexity
+Most complex method (~150 lines) with:
+- Pointer-style cell iteration (Java arrays instead)
+- Bit manipulation for Active Style Mask
+- Dynamic memory management
+- Left/right fill logic
+- Cell merging and accumulation
+
+### 2. Memory Management
+C++ uses pod_vector<> with direct pointer access.
+Java translation requires:
+- ArrayList management
+- Array resizing
+- Index-based access patterns
+
+### 3. Bit Operations
+Active Style Mask uses bitwise operations:
+```cpp
+unsigned nbyte = style_id >> 3;
+unsigned mask = 1 << (style_id & 7);
+if((m_asm[nbyte] & mask) == 0) { ... }
+```
+
+### 4. Color Blending
+render_scanlines_compound has complex blending:
+- Mix buffer for overlapping styles
+- Per-pixel alpha accumulation
+- Full coverage vs partial coverage handling
+
+## Estimated Remaining Work
+
+| Component | Lines | Complexity | Status |
+|-----------|-------|------------|--------|
+| RasterizerCompoundAa.sweepStyles() | 150 | High | Not started |
+| RasterizerCompoundAa.sort() | 30 | Low | Not started |
+| RasterizerCompoundAa.rewindScanlines() | 50 | Medium | Not started |
+| RasterizerCompoundAa other methods | 70 | Low | Not started |
+| StyleHandler interface | 30 | Low | Not started |
+| render Scanlines compound | 150 | High | Not started |
+| Integration | 100 | Medium | Not started |
+| **TOTAL** | **~580** | **-** | **~30% done** |
+
+## Next Steps
+
+1. Complete sweepStyles() implementation (most critical, most complex)
+2. Implement sort() and rewindScanlines()
+3. Create StyleHandler interface
+4. Translate renderScanlinesCompound
+5. Integrate with FlashRasterizerExample
+6. Test with complex shapes
+7. Debug and refine
+
+## References
+
+### C++ Source Files
+- `/agg-src/include/agg_rasterizer_compound_aa.h` - Main compound rasterizer
+- `/agg-src/include/agg_renderer_scanline.h` - render_scanlines_compound
+- `/agg-src/examples/flash_rasterizer.cpp` - Usage example
+
+### Key Algorithms
+- Active Style Table (AST) building
+- Active Style Mask (ASM) bit operations
+- Cell-level left/right fill tracking
+- Per-style scanline generation
+- Multi-style color blending
+
+## Timeline Estimate
+
+Given complexity and need for careful testing:
+- **sweepStyles()**: 2-3 hours (complex algorithm translation)
+- **Other RasterizerCompoundAa methods**: 1 hour
+- **StyleHandler + renderScanlinesCompound**: 2 hours  
+- **Integration + testing**: 2 hours
+- **Total**: 7-8 hours of focused development
+
+---
+
+*Last Updated: 2025-10-29*
+*Status: 30% complete, core infrastructure done, sweep algorithms in progress*

agg-java/COMPOUND_RASTERIZER_PLAN.md

@@ -0,0 +1,85 @@
+# Compound Rasterizer Implementation Plan
+
+## Overview
+Translating AGG's RasterizerCompoundAa (~665 lines C++) to Java for perfect polygon stitching in Flash compound shapes.
+
+## Core Concept
+Unlike simple rasterization which treats each path independently, compound rasterization:
+1. Tracks LEFT and RIGHT fill styles for each cell
+2. Groups cells by style during scanline sweep  
+3. Blends overlapping styles per pixel
+4. Achieves perfect stitching at polygon boundaries
+
+## Implementation Phases
+
+### Phase 1: Data Structures ✅ COMPLETE
+- [x] CellStyleAa - Cell with left/right style indices
+- [x] StyleInfo - Per-style cell tracking  
+- [x] CellInfo - Simplified cell for rendering
+
+### Phase 2: RasterizerCompoundAa Core (IN PROGRESS)
+- [ ] Basic structure and fields
+- [ ] styles() method - Set left/right fills for edges
+- [ ] add_path() / add_vertex() - Path addition
+- [ ] sort() / rewind_scanlines() - Preparation
+
+### Phase 3: Scanline Sweeping  
+- [ ] sweep_styles() - Group cells by style for current scanline
+- [ ] sweep_scanline() - Extract cells for specific style
+- [ ] style() - Get style ID from index
+
+### Phase 4: Supporting Classes
+- [ ] ScanlineBin - Binary scanline (no AA data, just spans)
+- [ ] SpanAllocator - Memory allocation for color spans
+- [ ] StyleHandler - Interface for color lookup by style
+
+### Phase 5: Rendering
+- [ ] render_scanlines_compound() - Main rendering method
+- [ ] Color blending logic for overlapping styles
+- [ ] Integration with existing renderer
+
+### Phase 6: Integration
+- [ ] Update FlashRasterizerExample to use compound rasterizer
+- [ ] Remove flash_rasterizer2 approach  
+- [ ] Test with Flash shapes
+
+## Key Challenges
+
+### 1. Cell Management
+C++ uses `cell_style_aa` cells stored in `rasterizer_cells_aa<cell_style_aa>`.
+Java solution: Extend RasterizerCellsAa to work with CellStyleAa.
+
+### 2. Style Tracking
+Compound rasterizer maintains:
+- m_styles: Array of StyleInfo (one per fill index)
+- m_ast: Active Style Table (unique styles in scanline)
+- m_asm: Active Style Mask (bitmap of active styles)
+- m_cells: Array of CellInfo (cells grouped by style)
+
+### 3. Two-Pass Rendering
+For multiple styles on same scanline:
+1. Sweep binary scanline to get span coverage
+2. Clear mix_buffer for those spans
+3. For each style: sweep AA scanline, blend into mix_buffer  
+4. Render final mix_buffer to output
+
+## Estimated Scope
+- RasterizerCompoundAa: ~400 lines
+- ScanlineBin: ~100 lines
+- SpanAllocator: ~50 lines
+- StyleHandler: ~30 lines  
+- render_scanlines_compound: ~150 lines
+- Updates/Integration: ~100 lines
+**Total: ~830 lines new Java code**
+
+## Current Status
+✅ Phase 1 complete (data structures)
+🔄 Phase 2 in progress (rasterizer core)
+
+## Next Steps
+1. Create RasterizerCompoundAa skeleton
+2. Implement styles() and path addition
+3. Implement sweep_styles() - most complex part
+4. Create supporting classes
+5. Implement render_scanlines_compound
+6. Test and refine

agg-java/DebugInversion.java

@@ -0,0 +1,35 @@
+import agg.*;
+
+public class DebugInversion {
+    public static void main(String[] args) {
+        // Simulate the first triangle
+        PathStorage path = new PathStorage();
+        path.moveTo(0, 0);
+        path.lineTo(50, 50);
+        path.lineTo(0, 50);
+        path.lineTo(0, 0);  // Explicit close
+
+        System.out.println("Original path:");
+        printPath(path);
+
+        System.out.println("\nInverting polygon...");
+        path.invertPolygon(0);
+
+        System.out.println("\nInverted path:");
+        printPath(path);
+    }
+
+    static void printPath(PathStorage path) {
+        path.rewind(0);
+        double[] xy = new double[2];
+        int cmd;
+        int count = 0;
+        while (!AggBasics.isStop(cmd = path.vertex(xy))) {
+            String cmdName = AggBasics.isMoveTo(cmd) ? "MOVE_TO" :
+                           AggBasics.isLineTo(cmd) ? "LINE_TO" :
+                           AggBasics.isClose(cmd) ? "CLOSE" : "VERTEX";
+            System.out.printf("  %d: %s (%.1f, %.1f)%n", count++, cmdName, xy[0], xy[1]);
+        }
+        System.out.println("  Total: " + count + " vertices");
+    }
+}

agg-java/DebugRasterizer.java

@@ -0,0 +1,46 @@
+import agg.*;
+
+public class DebugRasterizer {
+    public static void main(String[] args) {
+        RasterizerScanlineAa ras = new RasterizerScanlineAa();
+        ras.autoClose(false);
+
+        System.out.println("Before adding path:");
+        System.out.println("  started = " + getStarted(ras));
+        System.out.println("  minX/maxX = " + ras.minX() + "/" + ras.maxX());
+        System.out.println("  minY/maxY = " + ras.minY() + "/" + ras.maxY());
+
+        // Add a simple triangle: LINE_TO, LINE_TO, MOVE_TO (inverted form)
+        ras.lineToD(0, 50);
+        System.out.println("\nAfter first LINE_TO(0, 50):");
+        System.out.println("  started = " + getStarted(ras));
+        System.out.println("  minX/maxX = " + ras.minX() + "/" + ras.maxX());
+
+        ras.lineToD(50, 50);
+        System.out.println("\nAfter second LINE_TO(50, 50):");
+        System.out.println("  started = " + getStarted(ras));
+        System.out.println("  minX/maxX = " + ras.minX() + "/" + ras.maxX());
+
+        ras.moveToD(0, 0);
+        System.out.println("\nAfter MOVE_TO(0, 0):");
+        System.out.println("  started = " + getStarted(ras));
+        System.out.println("  minX/maxX = " + ras.minX() + "/" + ras.maxX());
+
+        boolean ready = ras.rewindScanlines();
+        System.out.println("\nRasterizer ready: " + ready);
+        System.out.println("  minX/maxX = " + ras.minX() + "/" + ras.maxX());
+        System.out.println("  minY/maxY = " + ras.minY() + "/" + ras.maxY());
+
+        ScanlineU8 sl = new ScanlineU8();
+        int count = 0;
+        while (ras.sweepScanline(sl)) {
+            count++;
+        }
+        System.out.println("Total scanlines: " + count);
+    }
+
+    private static boolean getStarted(RasterizerScanlineAa ras) {
+        // We can't access private field, so just return unknown
+        return false; // Can't access
+    }
+}