@lark-apaas/coding-steering 0.1.32-dev.5abff3b → 0.1.32-dev.6ef2b6f

package/steering/design-html/skills/pptx-style-extract/scripts/extract.py

@@ -181,6 +181,8 @@ def export_media(pkg, images, outdir, pillow_ok, export_all=False):
                 reasons.append('variant_group')
             if info['stitch_candidate']:
                 reasons.append('crop_stitch')
+            if info.get('visible_instance_blocked'):
+                reasons.append('visible_instance_fallback')
             if 0 < (info.get('max_w_pct') or 0) < SMALL_IMG_W_PCT and not info['fullscreen']:
                 # 小图（页内图标、角标）。不导出的话 L 层只能看着装饰容器里的空洞
                 # 自己编图形，编出来的与模板无关。
@@ -261,6 +263,30 @@ def _is_full_canvas_picture(shape):
             and (shape.get('h_pct') or 0) >= 95)
 
 
+def _shape_has_visible_text(shape):
+    text = shape.get('text') or {}
+    for paragraph in text.get('paragraphs') or []:
+        for run in paragraph.get('runs') or []:
+            if str(run.get('text') or '').strip():
+                return True
+    return False
+
+
+def _is_full_canvas_fill_overlay(shape):
+    fill = shape.get('fill') or {}
+    geometry = shape.get('geom') or {}
+    line = shape.get('line') or {}
+    return (shape.get('kind') == 'sp' and not shape.get('hidden')
+            and fill.get('type') in ('solid', 'gradient')
+            and not fill.get('path')
+            and geometry.get('prst') == 'rect'
+            and not shape.get('rot')
+            and not line.get('color') and not line.get('gradient')
+            and not _shape_has_visible_text(shape)
+            and (shape.get('w_pct') or 0) >= 95
+            and (shape.get('h_pct') or 0) >= 95)
+
+
 def _picture_has_appearance(shape):
     return bool(shape.get('flipH') or shape.get('flipV') or shape.get('rot')
                 or shape.get('crop')
@@ -333,6 +359,147 @@ def _draw_picture(canvas, shape, pkg, image_cache=None):
     return True
 
 
+def _visible_picture_instance(shape, pkg, image_cache=None):
+    """Render one non-background picture exactly as its PPT instance appears."""
+    from PIL import Image
+
+    bounds = shape.get('box') or {}
+    source_box = shape.get('box_unrotated') or bounds
+    width = max(1, int(round(bounds.get('w') or 0)))
+    height = max(1, int(round(bounds.get('h') or 0)))
+    if not source_box.get('w') or not source_box.get('h'):
+        return None
+    local = dict(shape)
+    local['box_unrotated'] = {
+        'x': float(source_box.get('x') or 0) - float(bounds.get('x') or 0),
+        'y': float(source_box.get('y') or 0) - float(bounds.get('y') or 0),
+        'w': source_box['w'],
+        'h': source_box['h'],
+    }
+    canvas = Image.new('RGBA', (width, height))
+    if not _draw_picture(canvas, local, pkg, image_cache):
+        return None
+    return canvas if canvas.getchannel('A').getbbox() else None
+
+
+def _save_picture_instance_webp(canvas, path):
+    """Keep the instance alpha and shrink only after lossless output exceeds budget."""
+    def write(options):
+        temporary = path + '.tmp'
+        try:
+            canvas.save(temporary, 'WEBP', **options)
+            size = os.path.getsize(temporary)
+            os.replace(temporary, path)
+            return size
+        finally:
+            if os.path.exists(temporary):
+                os.unlink(temporary)
+
+    try:
+        size = write({'lossless': True, 'method': 0})
+    except Exception as exc:
+        return 'pillow-error: %s: %s' % (exc.__class__.__name__, exc)
+    if size <= ASSET_BUDGET_BYTES:
+        return None
+    for quality in (95, 90, 85, 75):
+        try:
+            size = write({'quality': quality, 'method': 6})
+        except Exception:
+            return None
+        if size <= ASSET_BUDGET_BYTES:
+            return None
+    return None
+
+
+def export_visible_picture_instances(pkg, shapes, outdir, pillow_ok, blocked=None):
+    """Replace transformed local pictures with rendered media consumers can reuse.
+
+    A raw media file cannot reproduce an instance-level crop, rotation, flip, or
+    opacity. Flattening only those non-fullscreen instances keeps the downstream
+    contract simple: every asset still resolves through ordinary ``source_media``.
+    """
+    if not pillow_ok:
+        return []
+    try:
+        from PIL import Image  # noqa: F401
+    except Exception:
+        return []
+
+    media_dir = os.path.join(outdir, 'media-out')
+    os.makedirs(media_dir, exist_ok=True)
+    blocked = blocked if blocked is not None else {}
+    rows_by_media, rendered_specs, image_cache = {}, {}, {}
+    for shape in shapes:
+        if (shape.get('kind') != 'pic' or shape.get('hidden')
+                or not shape.get('media') or shape.get('media') not in pkg.names
+                or _is_full_canvas_picture(shape) or not _picture_has_appearance(shape)):
+            continue
+        source = shape['media']
+        source_box = shape.get('box_unrotated') or shape.get('box') or {}
+        visible_box = shape.get('box') or {}
+        spec = json.dumps({
+            'source': source,
+            'source_size': [source_box.get('w'), source_box.get('h')],
+            'visible_size': [visible_box.get('w'), visible_box.get('h')],
+            'crop': shape.get('crop') or {},
+            'flipH': bool(shape.get('flipH')),
+            'flipV': bool(shape.get('flipV')),
+            'rot': shape.get('rot') or 0,
+            'opacity': shape.get('opacity', 1.0),
+        }, ensure_ascii=False, sort_keys=True)
+        media = rendered_specs.get(spec)
+        if media is None:
+            canvas = _visible_picture_instance(shape, pkg, image_cache)
+            if canvas is None:
+                continue
+            digest = hashlib.sha256(spec.encode('utf-8')).hexdigest()[:16]
+            media = 'generated/instance/picture-%s.webp' % digest
+            out = 'media-out/' + os.path.basename(media)
+            path = os.path.join(outdir, out)
+            if not os.path.exists(path):
+                reason = _save_picture_instance_webp(canvas, path)
+                if reason:
+                    row = blocked.setdefault(source, {
+                        'reason': reason, 'attempted_specs': 0, 'part_refs': [],
+                    })
+                    row['attempted_specs'] += 1
+                    row['part_refs'].append(shape.get('part'))
+                    shape['visible_instance_blocked'] = reason
+                    rendered_specs[spec] = False
+                    continue
+            rendered_specs[spec] = media
+            rows_by_media[media] = {
+                'media': media,
+                'ext': 'webp',
+                'bytes': os.path.getsize(path),
+                'used_n': 0,
+                'reasons': ['visible_picture_instance'],
+                'candidate': True,
+                'exported': True,
+                'out': out,
+                'out_bytes': os.path.getsize(path),
+                'transcoded': False,
+                'generated': True,
+                'rendered_from': source,
+                'rendered_with': {
+                    key: shape[key] for key in ('crop', 'flipH', 'flipV', 'rot', 'opacity')
+                    if shape.get(key) not in (None, False, {}, 0, 1.0)
+                },
+                'part_refs': [],
+            }
+        elif media is False:
+            blocked[source]['part_refs'].append(shape.get('part'))
+            shape['visible_instance_blocked'] = blocked[source]['reason']
+            continue
+        row = rows_by_media[media]
+        row['used_n'] += 1
+        row['part_refs'].append(shape.get('part'))
+        shape['media'] = media
+        shape.pop('media_svg', None)
+        shape['rendered_from'] = source
+    return list(rows_by_media.values())
+
+
 def _draw_background(canvas, background, pkg, image_cache=None):
     """Draw the effective p:bg underneath picture layers."""
     from PIL import Image
@@ -353,6 +520,48 @@ def _draw_background(canvas, background, pkg, image_cache=None):
         }, pkg, image_cache)
 
 
+def _draw_background_fill_overlay(canvas, shape):
+    """Draw one full-canvas fill shape that visually modifies a background image."""
+    from PIL import Image
+    from render_pages import _grad_image, _grad_stops, _rgba, css_color, css_gradient
+
+    fill = shape.get('fill') or {}
+    box = shape.get('box_unrotated') or shape.get('box') or {}
+    width = max(1, int(round(box.get('w') or 0)))
+    height = max(1, int(round(box.get('h') or 0)))
+    x = int(round(box.get('x') or 0))
+    y = int(round(box.get('y') or 0))
+    if fill.get('type') == 'solid':
+        color = _rgba(css_color(fill.get('color')))
+        if color is None:
+            return False
+        overlay = Image.new('RGBA', (width, height), color)
+    elif fill.get('type') == 'gradient':
+        gradient = _grad_stops(css_gradient(fill) or '')
+        if not gradient:
+            return False
+        overlay = _grad_image(Image, width, height, gradient[0], gradient[1])
+    else:
+        return False
+    canvas.alpha_composite(overlay, (x, y))
+    return True
+
+
+def _background_layer_source(shape):
+    if shape.get('kind') == 'pic':
+        return {
+            'part': shape['part'], 'kind': 'picture', 'media': shape['media'],
+            'crop': shape.get('crop'), 'flipH': bool(shape.get('flipH')),
+            'flipV': bool(shape.get('flipV')), 'rot': shape.get('rot') or 0,
+            'opacity': shape.get('opacity', 1.0),
+        }
+    return {
+        'part': shape['part'], 'kind': 'fill_overlay',
+        'box': shape.get('box_unrotated') or shape.get('box'),
+        'fill': shape.get('fill'),
+    }
+
+
 def _save_background_webp(canvas, path):
     """Prefer lossless output; fall back to a quality ladder when oversized."""
     canvas.convert('RGB').save(path, 'WEBP', lossless=True, method=0)
@@ -398,15 +607,12 @@ def compose_backgrounds(pkg, graph, shapes, bg_by_part, units, outdir, pillow_ok
     image_cache = {}
     for target, chain in chains.items():
         layers = [shape for part in chain for shape in by_part.get(part, [])
-                  if _is_full_canvas_picture(shape)]
-        if not layers or (len(layers) == 1 and not _picture_has_appearance(layers[0])):
+                  if _is_full_canvas_picture(shape) or _is_full_canvas_fill_overlay(shape)]
+        pictures = [shape for shape in layers if shape.get('kind') == 'pic']
+        if not pictures or (len(pictures) == 1 and not _picture_has_appearance(pictures[0])
+                            and len(layers) == 1):
             continue
-        source_layers = [{
-            'part': shape['part'], 'media': shape['media'],
-            'crop': shape.get('crop'), 'flipH': bool(shape.get('flipH')),
-            'flipV': bool(shape.get('flipV')), 'rot': shape.get('rot') or 0,
-            'opacity': shape.get('opacity', 1.0),
-        } for shape in layers]
+        source_layers = [_background_layer_source(shape) for shape in layers]
         spec = json.dumps({
             'background': _effective_background(chain, bg_by_part),
             'layers': [{k: v for k, v in layer.items() if k != 'part'}
@@ -417,8 +623,12 @@ def compose_backgrounds(pkg, graph, shapes, bg_by_part, units, outdir, pillow_ok
             canvas = Image.new('RGBA', (units.w, units.h))
             _draw_background(
                 canvas, _effective_background(chain, bg_by_part), pkg, image_cache)
-            drawn = [shape for shape in layers
-                     if _draw_picture(canvas, shape, pkg, image_cache)]
+            drawn = [
+                shape for shape in layers
+                if (_draw_picture(canvas, shape, pkg, image_cache)
+                    if shape.get('kind') == 'pic'
+                    else _draw_background_fill_overlay(canvas, shape))
+            ]
             if len(drawn) != len(layers):
                 continue
             digest = hashlib.sha256(canvas.tobytes()).hexdigest()[:16]
@@ -826,6 +1036,9 @@ def extract(pptx, outdir, export_all=False):
                               'box_emu': {'x': 0, 'y': 0, 'cx': cx, 'cy': cy},
                               'crop': bg.get('crop'), 'placement': 'inside',
                               'w_pct': 100.0, 'h_pct': 100.0, 'in_group': False})
+    instance_blocked = {}
+    instance_media = export_visible_picture_instances(
+        pkg, shapes, outdir, pillow_ok, instance_blocked)
     images, variant_groups = image_census(shapes, bg_images, units)        # S5
     t = mark('S5_image_census', t)
 
@@ -845,6 +1058,10 @@ def extract(pptx, outdir, export_all=False):
     t = mark('derived_censuses', t)
 
     media_rows = export_media(pkg, images, outdir, pillow_ok, export_all)  # S9
+    for row in media_rows:
+        if row['media'] in instance_blocked:
+            row['visible_instance_blocked'] = instance_blocked[row['media']]
+    media_rows += instance_media
     background_composites, composite_media, composite_images = compose_backgrounds(
         pkg, graph, shapes, bg_by_part, units, outdir, pillow_ok)
     media_rows += composite_media
@@ -949,6 +1166,8 @@ def extract(pptx, outdir, export_all=False):
             'content_clusters_multi_media': sum(1 for c in clusters if c['member_n'] > 1),
             'media_exported': sum(1 for m in media_rows
                                   if m.get('exported') and not m.get('generated')),
+            'media_instances': len(instance_media),
+            'media_instance_blocked': len(instance_blocked),
             'media_transcoded': sum(1 for m in media_rows
                                     if m.get('transcoded') and not m.get('generated')),
             'media_transcode_blocked': sum(1 for m in media_rows

package/steering/design-html/skills/pptx-style-extract/scripts/parts.py

@@ -299,6 +299,22 @@ NV_TAGS = {'sp': 'p:nvSpPr', 'pic': 'p:nvPicPr', 'grpSp': 'p:nvGrpSpPr',
            'cxnSp': 'p:nvCxnSpPr', 'graphicFrame': 'p:nvGraphicFramePr'}
 
 
+def blip_opacity(blip):
+    """Combine the alpha modulation transforms attached to one local picture."""
+    opacity = 1.0
+    found = False
+    for effect in blip:
+        if local(effect.tag) not in ('alphaMod', 'alphaModFix'):
+            continue
+        try:
+            amount = int(effect.get('amt'))
+        except (TypeError, ValueError):
+            continue
+        opacity *= max(0.0, min(amount / 100000.0, 1.0))
+        found = True
+    return round(opacity, 6) if found else None
+
+
 def walk_tree(el, ctx, out, path=(), xf=(1.0, 1.0, 0.0, 0.0), depth=0):
     sx, sy, dx, dy = xf
     U, W, H = ctx.units, ctx.units.w, ctx.units.h
@@ -393,9 +409,9 @@ def walk_tree(el, ctx, out, path=(), xf=(1.0, 1.0, 0.0, 0.0), depth=0):
             blip = sp.find('p:blipFill/a:blip', NS)
             if blip is not None:
                 rec['media'] = ctx.media_of(blip.get(R_EMBED)) or ctx.media_of(blip.get(R_LINK))
-                alpha = blip.find('a:alphaModFix', NS)
-                if alpha is not None and alpha.get('amt') is not None:
-                    rec['opacity'] = round(int(alpha.get('amt')) / 100000.0, 6)
+                opacity = blip_opacity(blip)
+                if opacity is not None:
+                    rec['opacity'] = opacity
                 svg = blip.find('a:extLst//asvg:svgBlip', NS)
                 if svg is not None:
                     rec['media_svg'] = ctx.media_of(svg.get(R_EMBED))

package/steering/design-html/skills/pptx-style-extract/scripts/render_pages.py

@@ -88,13 +88,15 @@ def css_gradient(grad):
 def background_css(bg):
     """页底 <p:bg> 描述符 → CSS background 值。解析不出返回 None，交上层回退到下一层底色。
 
-    bgPr solid / bgRef 都带 `color`；gradient 与形状渐变共用 css_gradient；
-    背景图不重建（媒体未必导出），按无底色处理。
+    bgPr solid / bgRef 都带 `color`；线性 gradient 与形状渐变共用 css_gradient；
+    path 渐变和背景图不重建，按无底色处理，不能伪装成线性渐变。
     """
     if not bg:
         return None
     kind = bg.get('type')
     if kind == 'gradient':
+        if bg.get('path'):
+            return None
         return css_gradient(bg)
     if kind in ('image', 'none', 'pattern'):
         return None

package/steering/design-html/skills/pptx-style-extract/scripts/test_asset_judgment_package.py

@@ -438,6 +438,119 @@ class AssetJudgmentPackageTest(unittest.TestCase):
                 if result.fails
             ])
 
+    def test_package_places_a_rendered_picture_instance_as_a_logo_asset(self):
+        try:
+            from PIL import Image
+        except ImportError:
+            self.skipTest('Pillow unavailable')
+
+        with tempfile.TemporaryDirectory() as root:
+            stage1 = os.path.join(root, 'stage1')
+            lout = os.path.join(stage1, 'l-out')
+            pack = os.path.join(root, 'pack')
+            media = os.path.join(stage1, 'media-out')
+            ref = os.path.join(stage1, 'ref')
+            os.makedirs(lout)
+            os.makedirs(media)
+            os.makedirs(ref)
+
+            source = 'generated/instance/picture-directory-logo.webp'
+            output = 'picture-directory-logo.webp'
+            box = [1813, 18, 59, 228]
+            Image.new('RGBA', (59, 228), (20, 60, 100, 255)).save(
+                os.path.join(media, output), 'WEBP')
+            extract = {
+                'source': {'filename': 'fixture.pptx'},
+                'canvas': {
+                    'px': [1920, 1080],
+                    'source': {'cx': 12192000, 'cy': 6858000, 'unit': 'EMU'},
+                },
+                'media': [{
+                    'media': source,
+                    'out': 'media-out/' + output,
+                    'generated': True,
+                    'rendered_from': 'ppt/media/original-logo.png',
+                }],
+                'images': [{
+                    'media': source,
+                    'boxes': [{
+                        'count': 1,
+                        'box': dict(zip(('x', 'y', 'w', 'h'), box)),
+                        'parts': ['ppt/slides/slide2.xml'],
+                    }],
+                }],
+                'color_freq': [],
+                'text_scale': [],
+            }
+            with open(os.path.join(stage1, 'extract.json'), 'w', encoding='utf-8') as stream:
+                json.dump(extract, stream)
+            with open(os.path.join(ref, 'shapes.json'), 'w', encoding='utf-8') as stream:
+                json.dump({'shapes': [{
+                    'part': 'ppt/slides/slide2.xml',
+                    'kind': 'pic',
+                    'box': dict(zip(('x', 'y', 'w', 'h'), box)),
+                }]}, stream)
+            with open(os.path.join(lout, 'asset-vision-groups.json'),
+                      'w', encoding='utf-8') as stream:
+                json.dump({
+                    'version': 2,
+                    'selected': [{
+                        'candidates': [{
+                            'id': 'asset-directory-logo',
+                            'source_media': output,
+                            'placements': [{
+                                'slide': 2,
+                                'archetype': 'content',
+                                'box': box,
+                            }],
+                        }],
+                    }],
+                    'omitted': [],
+                }, stream)
+            with open(os.path.join(lout, 'manifest.yaml'), 'w', encoding='utf-8') as stream:
+                stream.write(
+                    'version: alpha\n'
+                    'name: rendered-instance-fixture\n'
+                    'description: Rendered local PPT image instances remain reusable assets.\n'
+                    'asset_vision_groups:\n'
+                    '  - id: asset-directory-logo\n'
+                    '    source_media: picture-directory-logo.webp\n'
+                    '    box: [1813, 18, 59, 228]\n'
+                    '    visual_kind: logo\n'
+                )
+            for name, content in (
+                ('frontmatter.yaml', ''),
+                ('body.md', 'Read `layouts.md` before composing a slide.\n\n{{ASSET_TABLE}}\n'),
+                ('layouts.yaml',
+                 'layouts:\n'
+                 '  content:\n'
+                 '    name: "目录"\n'
+                 '    role: content\n'
+                 '    slots:\n'
+                 '      - {role: asset-candidate, box: [1813, 18, 59, 228], type: pic, '
+                 'source_media: picture-directory-logo.webp}\n'
+                 '    confidence: high\n'),
+            ):
+                with open(os.path.join(lout, name), 'w', encoding='utf-8') as stream:
+                    stream.write(content)
+            check_v1 = os.path.join(root, 'check_v1.py')
+            with open(check_v1, 'w', encoding='utf-8') as stream:
+                stream.write('raise SystemExit(0)\n')
+
+            self.assertEqual(package_main([stage1, lout, pack, '--check-v1', check_v1]), 0)
+
+            with open(os.path.join(pack, 'design.md'), encoding='utf-8') as stream:
+                design = stream.read()
+            with open(os.path.join(pack, 'layouts.md'), encoding='utf-8') as stream:
+                layouts = stream.read()
+            self.assertTrue(os.path.isfile(os.path.join(pack, 'assets', 'logos', '1.webp')))
+            self.assertIn('logo-1:', design)
+            self.assertIn('assets/logos/1.webp', design)
+            self.assertIn(
+                '- {role: logo, box: [1813, 18, 59, 228], type: pic, asset: logo-1}',
+                layouts,
+            )
+
 
 if __name__ == '__main__':
     unittest.main()